标签：Java 可太 对象 System 爆肝 String 字符串 println out
这次是2021年01月21日，22日的学习成果，总结于此，以便于之后的学习查漏补缺
目录
Object
1、概述
在java中Object被定义为一个顶级父类，他是任何类的父类，我们可以显示的继承他，也可以隐示继承。
显示继承
public class Dog extends Object{
}
隐示继承
public class Dog{
}
Object 类是类层次结构的根，java中所有的类从更本上都继承自这个类。Object 类是java中唯一没有父类的类。其他所有的类，包括标准容器类，数组都继承了Object 类中的方法。
2、对象的字符串表示
(1) toString( )
toString用于返回对象的字符串表示。
当直接操作对象的引用变量时，JVM默认会调用toString 方法。例如:
System.out.println(new Object();这里将直接输出Object对象，代码中没有调用它的属性或方法，但是程序运行后会输出一个字符串。实际上，这里是由JVM自动调用了对象的toString方法，因此输出的字符串内容就是这个方法的返回值。
(2)对象的默认表示
在Object中，为Java对象提供了一-种默认的表示方法，即toString 的默认返回值，格式为“类的全路径名+@+引用地址”。例如，Person对象的字符串表示就是下面的形式:
com.cn.generallyclass.object.Person@xXXXXx
(3)重写toString
重写toString方法可以输出指定的数据表示：
创建Student类：
public class Student extends Object{
private String name;
private int age;
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
测试类：
public static void main(String[] args) {
Object object1 = new Object();
//输出时 包名 类名 @十六进制
System.out.println(object1.toString());
Student student1 = new Student();
student1.setName("ljj");
student1.setAge(21);
System.out.println(student1.toString());
Student student2 = new Student("zxx", 22);
System.out.println(student2.toString());
//syso里放一个对象，默认情况下，输出 对象.toString();
System.out.println(student2);
}
输出结果：
3、对象相等
在Java中支持判断两个对象是否相等，有两种含义:
1、表示两个对象是同一个对象(物理上相等，即同一对象)
2、表示两个对象的属性值是相等的，但两个对象并不是同一个对象(逻辑上相等，即不是相同对象，但对象的内容相等)
使用**==**比较对象引用地址，判断是否为同一对象。
使用equals 比较两个对象的内容，判断两个对象的内容是否相等。
比较引用地址 ( == )
==可用于判断基本数据类型的相等性,当然也可以直接判断两个对象的引用地址是否相等，从而判断两个对象是否为同一个对象。
例如，只创建一一个对象，两个变量都引用这个对象时，比较两个变量则值是相等的:
Object o = new Object();
Object o1 = o;
System.out.println("(o==o1): "+(o==o1)); // true
例如，创建两个新对象，由于这两个对象的内存地址是不同的，比较两个变量则值是不相等的。
Object o = new Object();
Object o1 = new Object();
System.out.println("(o==o1): "+(o == o1)); // false
比较对象内容（equals）
Object 的默认实现（equals）
Object 中 equals 方法的默认实现就是比较对象的引用地址， 即它的作用和 ’ == ’ 相同
public boolean equals(Object obj) {
return this == obj; // == 操作
}
hashCode
hashCode的用途 : 作为对象的标识。
hashCode为对象使用HASH算法计算对象的哈希值，同一个对象的哈希值是唯一的。
Java规定:如果两个对象使用equals方法比较后返回true,那么这两个对象的hashCode方法返回值必须一致。所以，我们重写类的equals方法后，都需要重写hashCode方法来满足这个规定。例如:
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Object1 other = (Object1) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
快速实现操作：在类中创建对象后，右键单击代码，选中Source，之后选中 Generate hashCode() and equals()… 选项，即可一键生成你设置对象的hashCode() and equals()重写方法
总结
1、public String toString():返回该对象的字符串表示。
一般建议重写该方法。
2、public final Class getClass():返回此Object 的运行时类。可以通过Class 类中的getName()方法，获取对象的真实类的全名称。
3、public int hashCode():返回该对象的哈希码值。简单地来说:hashcode不是对象的内存地址，但是是由内部地址(内存地址)转换而来的整数，不同对象的 hashCode()一 般来说不会相同。但是，同一个对象的hashCode()值肯定相同。
4、public boolean equals(Objectobj):指示其他某个对象是否与此对象“相等”。默认情况下比较的是对象的引用是否相同。由于比较对象的引用没有意义，一般建议重写该方法。
5、==号和equals方法:
==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值 , 引用数据类型比较的是两个对象的内存地址。默认情况下equals比较的是两个对象的内存地址。一般都会使用重写后的equals方法;在重写的equals方法中比较的两个对象中的属性。
字符串
概述
在Java中字符串是最广泛应用的数据。
Java提供了String、StringBuffer、StringBuilder类来创建和操作字符串。在Java中，字符串被当作对象来处理;它是引用类型数据。
字符串内存分析
字面量
字符串的每个字面量都是一个String对象，例如:String s = “hello world”;
新建对象
使用new创建字符串对象。例如：String s = new String(hello world);
字符串存储分析：
字面量保存在常量池中
在编译代码时，编译程序会将所有字面量都保存在方法区中的常量池里。因此，相同字面量的所有对象，实际上就是存储于常量池中的同一个对象。例如: .
String s1 = “Hello”;
String s2 = “Hello”;
这里s1和s2都是指向常量池中的"Hello"，因此，它们的引用地址是相同的。
System.out.println(s1 == s2); // true
使用new创建字符串保存在堆中
使用new创建时，将在堆中存储这个字符串对象。例如:
String s = new String(“Hello”);
其实,这里有两个对象，一个在常量池中,一个在堆中。虽然两个对象的内容是相同的，.但并不是同一个对象。
System.out.println(s == “Hello”); // false
常用方法
创建字符串
//创建字符串
String s01 = new String("hello");
//字节数组转换为字符串
byte[] byteArray = {97,98,99};
String s02 = new String(byteArray);
System.out.println(s02);
//* 字符数组转换为字符串
char[] charArray1 = {'a','b','c'};
String s03 = new String(charArray1);
System.out.println(s03);
//使用字符数组的一部分构建字符串对象
char[] charArray2 = {'a','b','c','d','e'};
//charArray2后面的2为偏移字符下标，1为偏移的量
String s04 = new String(charArray2,2,1);
System.out.println(s04);
length
获取字符串长度
String s = "abc";
System.out.println(s.length()); //3
字符串转换为字节数组或字符数组
//字符串转为字符数组
char[] arr=s03.toCharArray();
System.out.println(arr);
for(char ch:arr) {
System.out.println(ch);
}
//字符串转为字节数组
byte[] bytes = s02.getBytes();
for(byte b:bytes) {
System.out.println(b);
}
大小写转换
//小写转大写
String s05 = "hello";
String upperCase = s05.toUpperCase();
//大写转小写
String s06 = "ABC";
String lowerCase = s06.toLowerCase();
+
实现字符串的连接。字符串和任意类型之间使用"+"， 所有基本类型都转为字符串，所有引用类型都会调用toString，最后再执行字符串连接。
int age= 6;
String s="He is" + age + "years old.";
//s整个都是字符串型
System.out.println(s);
trim （修剪）
去掉字符串两端的空格
String s07 = " xs ";
String newString = s07.trim();
判断
String s07 = "asd";
String s08 = "ASD";
//判断两个字符串是否相同
System.out.println(s07.equals(s08)); //false
//判断两个字符串是否相同(忽略大小写)
System.out.println(s07.equalsIgnoreCase(s08)); //true
String s09 = "abcdef";
String s10 = "abc";
//判断字符串s09是否以s10开头
System.out.println(s09.startsWith(s10)); //true
//判断字符串s09是否以s10结尾
System.out.println(s09.endsWith(s10)); //false
//判断字符串s11是否为空
String s11 = " ";
System.out.println(s11.isEmpty()); //false
定位
String s15 = "asdfghj";
//返回指定索引的字符
char ch = s15.charAt(2); //d
String s16 = "zxcvxbnxm";
//返回此字符在字符串中第一次出现的索引值，如果都不匹配则返回-1
int index = s16.indexOf('v'); //3
index = s16.indexOf(2); // -1
//返回此字符在字符串中最后一次出现的索引值，如果都不匹配则返回-1
index = s16.lastIndexOf('x'); //7
index = s16.lastIndexOf(3); //-1
替换
//替换字符串中某字符
String s18 = "zabjkl";
String reS18 = s18.replace('a','v');
System.out.println(reS18); // zvbjkl
String s19 = "一支梨花";
String reS19 = s19.replace("梨花", "桃花");
System.out.println(reS19); // 一支桃花
子串
String s20 = "一支梨花压海棠";
//从下标为4的字符开始截取子串
s20.substring(4); //压海棠
//从下标为2的字符开始截取子串，截到3为止
s20.substring(2, 4); //梨花
比较
//按字典顺序比较两个字符串
//参数字符串等于此字符串，返回0
//此字符串按字典顺序小于参数字符串，返回小于0的值
//此字符串按字典顺序大于参数字符串，返回大于0的值
String s21 = "abd";
String s22 = new String("abc");
int result = s21.compareTo(s22);
System.out.println(result);
//按字典顺序比较两个字符串，忽略大小写
result = s21.compareToIgnoreCase(s22);
System.out.println(result);
运行结果：
拆分
String s23 = "asd-dfg-gjh-jkl";
//将字符串分割为一个字符串数组
//根据指定字符进行切割
String[] splitArray = s23.split("-");
for(String str:splitArray) {
System.out.println(str);
}
运行结果：
将其他数据转为字符串
//将其他数据类型转换为字符串，包括但不仅限于字符数组
char[] chs = {'a','c','n'};
System.out.println(String.valueOf(chs));
Scanner (了解)
Scanner用于接收用户的输入
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
System.out.println(a);
运行结果：第一个99为用户输入，第二个99为输出
Math
Math类是一个工具类，它在解决与数学有关的一些问题时有着非常重要的作用
1.入门
//求绝对值
int i = Math.abs(-6);
//求最大最小值
double max = Math.max(3.5, 6.6); //6.6
double min = Math.min(2.3, 5.6); //2.3
//向上，向下取整
double ceil = Math.ceil(9.01); //10
double floor = Math.floor(2.9); //2
//取0到1之间的随机数
System.out.println(Math.random());
//打印圆周率
System.out.println(Math.PI);
2.随机数
(1)使用Math.random()获取随机数
Random random = new Random();
//随机生成0到9的整数
int number = random.nextInt(10);
System.out.println(number);
(2)随机点名系统
String[] array= {"小明","小红","小强","小花","小白"};
//随机点名
Random random = new Random();
int index = random.nextInt(array.length);
String name = array[index];
System.out.println(name);
StringBuffer
个人理解：字符串加工厂
(1)为什么需要StringBuffer
由于String的内容是不可变的，在频繁操作字符串的应用中，导致String对象泛滥，不断的被创建和销毁，占用大量的内存和CPU时间。
例如，将十万个"A"连成一个大的字符串。代码如下:
String result= "";
for(int i= 0;i< 100000; i++){
result += "A";
}
这将创建100000个对象，其中有99999个对象是临时对象，是计算的中间结果。JVM需要花费大量的内存来存放，也需要花费大量CPU时间来回收对象。
因此，通常要使用可变的字符串缓冲区类(StringBuffer) 来完成类似的工作:
StringBuffer stringBuffer = new StringBuffer();
for(int i=1;i<100000;i++) {
stringBuffer.append("A");
}
String result = stringBuffer.toString();
这样，只需要创建一个StringBuffer和一个String对象就行了。
(2)缓冲原理
StringBuffer对象内部有一个缓冲区，默认缓冲区的容量是16字节。
通过StringBuffer的 append方法向缓冲区中不断追加数据，当数据的大小超过缓冲区的大小时，系统会重新创建一个原来缓冲区的一倍大的新缓冲区，并将原缓冲区中的数据拷贝到新缓冲区中，这个操作非常耗资源。因此，需要预估数据所占空间大小，在创建缓冲区时就预分配最大值，防止重新创建缓冲区，提高系统性能。
(3)常用方式
StringBuffer stringBuffer = new StringBuffer();
//在缓冲区尾部添加新的文本对象
stringBuffer.append(66);
stringBuffer.append("hi");
stringBuffer.append(3.14).append("asd").append(2.6);
//返回结果时默认加toString返回一个拼接后的字符串
System.out.println(stringBuffer);
运行结果：
(4)方法
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("abcdex");
System.out.println(stringBuffer); //abcdex
//返回当前容量
int capacity = stringBuffer.capacity();
System.out.println(capacity); // 16
//返回长度(字符数)
int length = stringBuffer.length();
System.out.println(length);
//不会影响之后的stringBuffer本身
//截取开始到结尾的字符串，包括开头，不包括结尾
String substring = stringBuffer.substring(0, 3);
System.out.println(substring); //abc
//从指定位置截取到末尾
String substring2 = stringBuffer.substring(3);
System.out.println(substring2); //dex
//会影响之后的stringBuffer本身
//删除指定位置的字符，并返回本身
StringBuffer deleteCharAt = stringBuffer.deleteCharAt(0);
System.out.println(deleteCharAt); // bcdex
//删除从指定位置开始到结束的内容，并返回本身
StringBuffer delete = stringBuffer.delete(0, 3);
System.out.println(delete); // ex
//从开始到结尾用指定字符串替换
StringBuffer replace = stringBuffer.replace(0, 3, "A**");
System.out.println(replace); //A**
//字符串反转
StringBuffer reverse = stringBuffer.reverse();
System.out.println(reverse); //**A
//替换指定位置的字符
stringBuffer.setCharAt(0, 'T');
System.out.println(stringBuffer); //T*A
//在指定的位置(字符个数后)添加新的文本对象
StringBuffer insert = stringBuffer.insert(2, "xx");
System.out.println(insert); //T*xxA
String，StringBuffer，StringBuilder
BigDecimal (精度高的小数)
由于在运算的时候, float和 double很容易丢失精度,为了能精确的表示和计算浮点数，Java提供了BigDecimal。
//double损失精度
double d1 = 0.1;
double d2 = 0.2;
//使用BigDecimal不会损失精度
BigDecimal b1 = new BigDecimal(d1);
BigDecimal b2 = new BigDecimal(d2);
//相加
System.out.println(b1.add(b2));
//相减
System.out.println(b1.subtract(b2));
//相乘
System.out.println(b1.multiply(b2));
//相除 ，第二个参数是小数点后保留几位，第三个参数是四舍五入
System.out.println(b1.divide(b2, 3, RoundingMode.HALF_UP));
运行结果：
字符串也可以：
BigDecimal bstr1 = new BigDecimal("0.1");
BigDecimal bstr2 = new BigDecimal("0.2");
//相加
System.out.println(bstr1.add(bstr2));
//相减
System.out.println(bstr1.subtract(bstr2));
//相乘
System.out.println(bstr1.multiply(bstr2));
//相除 ，第二个参数是小数点后保留几位，第三个参数是四舍五入
System.out.println(bstr1.divide(bstr2, 3, RoundingMode.HALF_UP));
运行结果：
System
System用于获取系统的属性。它不能被实例化。
//复制数组
int[] array1 = {1,2,3,4,5};
int[] array2 = new int[array1.length];
// array1:被复制数组 0:开始复制的位置 array2:得到复制的数组
// 1:将复制来的数组开始放入的位置 2：需要复制的长度
System.arraycopy(array1, 0, array2, 1, 2);
for(int i :array2) {
System.out.println(i);
}
运行结果：
//1970.1.1到现在的毫秒数
long time = System.currentTimeMillis();
//运行垃圾回收器(一定程度加速垃圾回收)
System.gc();
//JVM虚拟机退出
System.exit(0);
Runtime
Runtime类只要描述的是应用程序运行的环境。
Runtime runtime = Runtime.getRuntime();
//获得可用内存(单位：字节)
long freeMemory = runtime.freeMemory();
//获得JVM最大内存容量(单位：字节)
long maxMemory = runtime.maxMemory();
//获得总内存(单位：字节)
long totalMemory = runtime.totalMemory();
枚举
一些方法运行时，其中，元素较少且范围固定，在java1.5之后，我们可以用枚举来解决。
例如：
交通灯：红 黄 绿
星期：星期一到星期天
季节：春夏秋冬
定义枚举类：
public enum Season {
SPRING,SUMMER,AUTUMN,WINTER
}
测试类：
public class Test3 {
public static void main(String[] args) {
Season s = Season.SPRING;
switch (s) {
case SPRING:
System.out.println("春天");
break;
case SUMMER:
System.out.println("夏天");
break;
case AUTUMN:
System.out.println("秋天");
break;
case WINTER:
System.out.println("冬天");
break;
default:
System.out.println("输入错误");
break;
}
}
}
基本数据类型的包装类
| 基本数据类型 | 对应包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
Integer
将一个int的基本类型数值变为一个对象，该类提供了多个方法，可以在int类型和String类型之间相互转换。
Integer integer = new Integer(987);
System.out.println(integer);
//将包装去除，拿到int类型数值
System.out.println(integer.intValue());
//int类型最大最小值
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
String string = "99";
//将字符串类型转化为Integer对象
integer = Integer.valueOf(string);
System.out.println(integer);
//将一个字符串类型转化为int类型
System.out.println(integer.intValue());
Integer integer2 = new Integer(66);
//将int类型转换为字符串类型
System.out.println(integer2.toString());
//将int类型转换为二进制字符串
System.out.println(integer2.toBinaryString(5));
//将int类型转换为八进制字符串
System.out.println(integer2.toOctalString(6));
//将int类型转换为十六进制字符串
System.out.println(integer2.toHexString(7));
Character
Character character = new Character('a');
char ch = character.charValue();
System.out.println(ch);
//判断指定字符是否为数字
System.out.println(Character.isDigit(ch));
//判断指定字符是否为字母
System.out.println(Character.isLetter(ch));
//判断指定字符是否为小写字母
System.out.println(Character.isLowerCase(ch));
//判断指定字符是否为大写字母
System.out.println(Character.isUpperCase(ch));
//返回表示此Character值的String对象
String string = character.toString();
System.out.println(string);
技巧
当涉及到基本类型相互转换，或基本类型和String类型相互转换时，可以考虑使用包装类型。
自动装箱和自动拆箱
自动装箱是把一个基本数据类型直接赋给对应的包装类。
自动拆箱是把一个包装类对象直接赋给对应的基本数据类型。
//自动装箱
Integer i = 12;
//自动拆箱
int j = i;
时间和日期
Local
Locale对象表示了特定的地理，政治和文化地区
//得到默认
Locale locale = Locale.getDefault();
//得到国家
String country = locale.getCountry();
//得到语言
String language = locale.getLanguage();
System.out.println(country); //CN
System.out.println(language); //zh
java.util.Date
java.util.Date类表示特定的瞬间，精确到毫秒
import java.util.Date;
public class Test7 {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);
//1970.1.1至今的毫秒数
long time = date.getTime();
System.out.println(time);
}
}
java.sql.Date
一个包装了毫秒值的瘦包装器(thin wrapper)，它允许JDBC将毫秒值标识为SQL DATE值
import java.sql.Date;
public class Test7 {
public static void main(String[] args) {
long time = System.currentTimeMillis();
//将毫秒转化为时间
Date date = new Date(time);
System.out.println(date); //2021-03-15
//将字符串转化为时间
Date d = Date.valueOf("2021-03-15");
System.out.println(d); //2021-03-15
}
}
java.util.Date与java.sql.Date的关系：
java.util.Date是父类
java.sql.Date是子类
SimpleDateFormat
DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化，并解析日期或时间。
把日期对象转换成字符串
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class Test7 {
public static void main(String[] args) {
Date date = new Date();
System.out.println("格式化前的日期Date为："+date);
String pattern = "yyyy-MM-dd HH:mm:ss";
Locale locale = Locale.getDefault();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern, locale);
String time = simpleDateFormat.format(date);
System.out.println("格式化后的时间字符串为："+time);
}
}
运行结果：
把字符串转换成日期对象
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class Test7 {
public static void main(String[] args) throws ParseException {
String time = "2021年03月15日 21:58:36";
String pattern = "yyyy年MM月dd日 HH:mm:ss";
Locale locale = Locale.getDefault();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern, locale);
Date date = simpleDateFormat.parse(time);
System.out.println(date);
}
}
运行结果：
将时间戳转换为时间字符串
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class Test8 {
public static void main(String[] args){
Date date = new Date();
long time = date.getTime();
System.out.println(time);
String pattern = "yyyy年MM月dd日 HH:mm:ss";
Locale locale = Locale.getDefault();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern, locale);
Long timeLong = new Long(time);
String string = simpleDateFormat.format(timeLong);
System.out.println(string);
}
}
运行结果：
将时间字符串转换为时间戳
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class Test7 {
public static void main(String[] args) throws ParseException {
String time = "2021年03月15日 21:58:36";
String pattern = "yyyy年MM月dd日 HH:mm:ss";
Locale locale = Locale.getDefault();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern, locale);
Date date = simpleDateFormat.parse(time);
long timeStamp = date.getTime();
System.out.println(timeStamp);
}
}
运行结果：
标签：Java,可太,对象,System,爆肝,String,字符串,println,out 来源： https://blog.csdn.net/qq_49290616/article/details/114252404
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。