Java常用类(2021.03.23)

Posted 努力努力再努力²

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java常用类(2021.03.23)相关的知识,希望对你有一定的参考价值。

目录


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方法中比较的两个对象中的属性。

4、字符串

概述
在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为输出

5、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
  //四舍五入
  int n=Math.round(2.51); //3
  int m=Math.round(2.49); //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);

6、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(delete

以上是关于Java常用类(2021.03.23)的主要内容,如果未能解决你的问题,请参考以下文章

2021-03-23 特征选择的效果评估

许地山-梨花

16个IO常用流

宋词:一剪梅,雨打梨花深闭门。唐寅

java —— String 类

梨花落(短篇小说)