Java中API常用的类和一些方法 Object类 Arrays类 Integer类 String类

我不是女神ヾ 2023-10-13 22:07 66阅读 0赞

#### 文章目录 ####

*   *  API
 *  Object类
 *   *  toString
     *  equals
 *  Arrays类
 *   *  equals 方法
     *  binarySearch(二分查找法)
     *  Copyof(数组复制)
     *  sort(排序)
 *  基本数据类型的包装类
 *   *  Integer
     *   *   *  声明
             *  调用非静态方法
             *   *  int compareTo();
                 *  boolean equals();
             *  调用静态方法
             *   *  Integer valueOf
                 *  int compare(int a,int b)
     *  装箱和拆箱
 *  String类
 *   *  字符串创建的两种方式
     *  \*\*构造方法\*\*
     *  \*\*成员方法(常用)\*\*
     *   *  判断功能
         *   *  boolean equals(String str);
             *  boolean equalsIgnoreCase(String str);
             *  \*oolean contains(String str)
             *  \*\*boolean isEmpty()\*\*
         *  获取功能
         *   *  \*\*byte\[\] getBytes()\*\*
             *  char\[\] toCharArray()
             *  int length();
             *  char charAt(int index)
             *  int indexOf(int ch)
             *  int indexOf(String str)
             *  int index(int ch/String str,int fromIndex)
             *  String substring(int start);
             *  String substring(int start,int end);
         *  转化功能
         *   *  byte\[\] getByte();
             *  char\[\] toCharArray();
             *  static String valueOf(char\[\] chs)
             *  String toLowerCase();
             *  String toUpperCase();
             *  String concat(String str);
             *  String\[\] split(分割符)
             *  String replace(char old,char new);
             *  String replace(String old,String new);
             *  String replaceAll(String regex, String replacement);
             *  replaceFirst(String regex, String replacement);
             *  public class StringUtil(自己定义工具类)
             *  String replace(String old,String new);
             *  String replaceAll(String regex, String replacement);
             *  replaceFirst(String regex, String replacement);
             *  public class StringUtil(自己定义工具类)

### API ###

**常用类:java系统中提供的一些使用频率较高的类**

**API(Application Programming Interface)应用程序接口**

*  java系统中所提供的一系列类和接口

API文档:官方给广大开发者学习者提供对类和接口功能的说明文档

## Object类 ##

java.lang.Object 是java类体系的最顶级,万类之祖

### toString ###

当我们输出一个对象时,会默认调用toString()方法,把对象以字符串形式输出

public class A extends Object{
        
        private String name;
    
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
        @Override
        public String toString() {
        //相当于把Object的toString方法重写
            return name;
        }
    }
    class test{
        
        public static void main(String[] args) {
        
            A a=new A();
            a.setName("崔渭阳");
            System.out.println(a);//默认调用toString();方法
        }
    }

类中如果没有toString(),那么父类会调用(Object)中的toString();

public String toString(){
        
    		Object类中的默认输出类的名字和对象在内存中的地址(10进制转化6进制)
    		return get getClass().getName+"@"+Integer.toHexString(hashCode());
    }

### equals ###

**String类中equals()用来比较字符串内容是否相等**

**Object 中equals()用来表示两对象地址是否相等,可以通过方法的重写修改来比较对象中的内容是否相等**

public class A extends Object{
        
        private String name;
        private int age;
    
        public A(String name,int age){
        
            this.name=name;
            this.age=age;
        }
    
        @Override
        public boolean equals(Object obj) {
        
            if(obj==null){
        
                return false;
            }
            if(this==obj){
        
                return true;
            }
            if(obj instanceof A){
        
                A a=(A)obj;
            return this.name.equals(a.name)&&age==age;
            }
            return false;
        }
        class test{
        
        public static void main(String[] args) {
        
            A a=new A("张三",18);
            A b=new A("张三",18);
            System.out.println(a.equals(b));
        }
    }
        结果:ture;

== 用于基本类型代表数值是否相等,在引用类型中代表地址是否相等\*\*

## Arrays类 ##

### equals 方法 ###

**比较两个数组中的元素内容是否相等**

import java.util.Arrays;
    
    public class ArraysEQuals {
        
        public static void main(String[] args) {
        
            int[]a={
        1,2,3,4,5,6};
            int[]b={
        1,2,3,4,5,6};
            System.out.println(a.equals(b));//直接用的是Object类,因为数组也是对象
            System.out.println(Arrays.equals(a,b));//调用Arrays类中的equals,比较两个数组元素内容
        }
    }

### binarySearch(二分查找法) ###

**必须是有序数组，若找到返回脚码(索引)，若没找到返回负数**

import java.util.Arrays;
    
    public class ArraysBinarySearch {
        
    
        public static void main(String[] args) {
        
            int[]a={
        1,2,3,4,5,6,7};//必须有序数组
            int index= Arrays.binarySearch(a,2);
            System.out.println(index);
        }
    
    }
    结果：
    	1

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dHWXGukG-1690006486218)(C:\\Users\\32477\\AppData\\Roaming\\Typora\\typora-user-images\\1689664412858.png)\]

*  也支持区间查找Arrays.binarySearch(数组,起始区间,结束区间,目标元素);//检索范围包含起始，不包含结尾

index=Arrays.binarySearch(a,0,4,2);
            System.out.println(index);
    结果
    	1

### Copyof(数组复制) ###

解决了不能改变数组长度的弊端

**将原来数组内容和新定义的newLength返回个新数组**

public class ArraysCopyof {
        
        public static void main(String[] args) {
        
            int[] a={
        1,2,3,4,5};
            System.out.println(Arrays.toString(a));
            a= Arrays.copyOf(a,20);
            System.out.println(Arrays.toString(a));//自己延长自己
            //Arrays.toString(a);遍历数组
            
        }
    }

### sort(排序) ###

*  对数组(基本数据,引用数据类型)排序 **引用数据排序需要实现**
 *  还可以对数组区间排序(包含起始不包含末端)
 *  还可以定义排序方法
 *  **默认升序排序**

package arraysdemos;
    
    import java.util.Arrays;
    
    public class ArraysSort {
        
        public static void main(String[] args) {
        
            int []a={
        1,2,7,9,9,0,3};
            Arrays.sort(a);
            System.out.println(Arrays.toString(a));
        }
    }
    结果:
    [0, 1, 2, 3, 7, 9, 9]

import java.util.Arrays;
    
    public class ArraysSort {
        
        public static void main(String[] args) {
        
            int []b={
        1,2,7,9,9,0,3};      
            Arrays.sort(b,0,4);
            System.out.println(Arrays.toString(b));
        }
    }
    结果:[1, 2, 7, 9, 9, 0, 3]

**对对象某个属性进行排序**

package arraysdemos;
    
    import java.util.Arrays;
    
    class Student implements Comparable<Student>{
        //需要实现Comparable接口
        private String name;
        private String id;
    
        public Student(String name,String id) {
        
            this.name=name;
            this.id=id;
        }
    
        @Override
        public String toString() {
        
            return this.name+this.id;
        }
    
        @Override
        public int compareTo(Student o) {
        
            return this.id.compareTo(o.id);
        }
    }
    class ArraysSort {
        
        public static void main(String[] args) {
        
            Student [] stu=new Student[4];
            Student people=new Student("张一","1314521");
            stu[0]=people;
            stu[1]=new Student("张二","1314523");
            stu[2]=new Student("张四","1314522");
            stu[3]=new Student("张三","1314524");
            Arrays.sort(stu);
            System.out.println(Arrays.toString(stu));
        }
    }
    结果
    [张一1314521, 张四1314522, 张二1314523, 张三1314524]

## 基本数据类型的包装类 ##

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面  
向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设  
计类时为**每个基本数据类型设计了一个对应的类进表示，这样八个和基  
本数据类型对应的类统称为包装类**

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装类(包裹类型)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ｂｙtｅ</td> 
   <td>Ｂｙｔｅ</td> 
  </tr> 
  <tr> 
   <td>ｓｈｏｒｔ</td> 
   <td>Ｓｈｏｒｔ</td> 
  </tr> 
  <tr> 
   <td>ｃｈａｒ</td> 
   <td>Ｃｈａｒａｃｔｅｒ</td> 
  </tr> 
  <tr> 
   <td>ｉｎｔ</td> 
   <td>I ｎｔｅｇｅｒ</td> 
  </tr> 
  <tr> 
   <td>ｌｏｎｇ</td> 
   <td>Ｌｏｎｇ</td> 
  </tr> 
  <tr> 
   <td>ｆｌｏａｔ</td> 
   <td>Ｆｌｏａｔ</td> 
  </tr> 
  <tr> 
   <td>ｄｏｕｂｌｅ</td> 
   <td>Ｄｏｕｂｌｅ</td> 
  </tr> 
  <tr> 
   <td>ｂｏｏｌｅａｎ</td> 
   <td>Ｂｏｏｌｅａｎ</td> 
  </tr> 
 </tbody> 
</table>

### Integer ###

##### 声明 #####

Integer a=new Integer(12);
            Integer b=new Integer(10);

##### 调用非静态方法 #####

###### int compareTo(); ######

###### boolean equals(); ######

//调用非静态方法
            System.out.println(a.compareTo(b));//前面大返回1,后面大返回-1,一样大返回0;
            System.out.println(a.equals(b));//比较a与b内容是否相同 与"=="要区分 返回一个boolean类型
            System.out.println(a==b);//比较a与b是否指向一个内容
            //.....

##### 调用静态方法 #####

###### Integer valueOf ######

###### int compare(int a,int b) ######

//调用静态方法
    		Integer c=Integer.valueOf(12);//调用静态方法,返回一个Integer类型变量给C
            Integer d=Integer.valueOf("10");//调用静态方法,把字符串类型(必须是数字)转换为Integer返回一个Integer类型变量
            System.out.println(Integer.compare(13,10));//前面大返回1,后面大返回-1,一样大返回0;
            System.out.println(Integer.max(13,10));//返回较大的数值
            System.out.println(Integer.valueOf(10));//返回的时引用类型

### 装箱和拆箱 ###

*  装箱:

将基本类型可以自动转换为包装类型

Integer a=10;//默认调用Integer.valueOf(a)把10转化为引用类型即Integer类型

*  拆箱:.

将包装类型转化为基本类型

int c=a.intValue();//拆箱
    int c=a;//自动拆箱

源码: 
    public static Integer valueOf(int i) {
        //low:-128;high:127
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);    
        }

Integer a=10;//默认调用Integer.valueOf(a)
            Integer a=10;
            Integer b=10;
            System.out.println(a.equals(b));//结果为true
    		System.out.println(a==b);//结果也为true
    		Integer c=128;
            Integer d=128;
            System.out.println(c==d);//结果为false
            System.out.println(c.equals(d));//结果为true

**有源代码可知,当在方法内部对 -128~127之间进行缓存(数组),在此期间的自动装箱,不会创建新的Integer对象,直接从中获得,(因为a与b传过去对应i的参数都为10,则返回的是同一个对象地址的引用),而超出此区间的每次都会返回新的对象(所以c和d虽然值相等但是返回的都是一个新的对象地址,所有c==d结果为false)**

## String类 ##

*  java中使用\*\*" "\*\*括起来的,都是String类的实例(对象)
 *  字符串的值是不可以被修改的,一旦字符串对象被创建,值就不能被改变

String s="abc";
    s+="aaa";
    s+="bbb";
    s+="ccc";
    System.out.println(s);//结果为abcaaabbbccc
    //实际上每次的字符串连接都是创建新的对象病赋值给s;s+="aaa"表示abcaaa这个新对象然后赋值给s,依次类推....;

**底层存储字符串内容的是数组,是被final修饰的,必须在创建之初由构造方法对其赋值**

### 字符串创建的两种方式 ###

*  方式1：

String s = "abc";

String s1 = "abc";
    String s2 = "abc";
    在第一此创建s1变量时，会去内(堆内存)中有一个叫字符常量池的空间检索,有没有与内容相同的字符串对象,如果没有就会在字符串常量池中创建一个字符串对象,把对象的地址赋值给s1,在第二次创建s2这个变量时,继续会去字符串常量池去检索,如果有,直接把之前的字符串内容的对象赋值给s2
    System.out.println(s1==s2);//结果为true

*  方法2：

String s1 = new String("abc");
    String s2 = new String("abc");
    这种方法每次都会创建新的字符串对象
    System.out.println(s1==s2);//结果为false

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iqsDXt1O-1690006486219)(C:\\Users\\32477\\Desktop\\java 课程\\笔记\\无标题.png)\]

### **构造方法** ###

*  无参构造:

String s1=new String();//无参构造,相当于this.value = "".value;
    //        public String() {
        
    //            this.value = "".value;
    //        }源码

*  有参构造

String s2=new String("abc123");//有参构造

### **成员方法(常用)** ###

#### 判断功能 ####

##### boolean equals(String str); #####

*  判断俩个字符串内容是否相等

String s4="abcd";
            System.out.println(s4.equals("abcD"));//false

##### boolean equalsIgnoreCase(String str); #####

*  判断两个字符串内容是否相等**不区分大小写**

System.out.println(s4.equalsIgnoreCase("ABcD"));//true

##### \*oolean contains(String str) #####

*  判断str是否为子串(**字符串必须连续**)

System.out.println(s4.contains("ab"));//true
    		System.out.println(s4.contains("ad"));//false

##### **boolean isEmpty()** #####

*  判断字符串是否为空字符串
    
    **注:“”–>指空字符串,而null–>指的是空地址并不能进行使用,否则会报错**

String s5="";
    		System.out.println(s4.isEmpty());//true

#### 获取功能 ####

##### **byte\[\] getBytes()** #####

*  //将字符串转化为编码,存在byte数组中并返回数组首地址

String s2=new String("abc123");//有参构造
            //把字符串处理为编码返回给byte数组;
            byte []bytes=s2.getBytes();
            System.out.println(Arrays.toString(bytes));
    结果:[97, 98, 99, 49, 50, 51]

**当然也可以通过有参构造方法将byte数组的编码转化为字符串new String(byte\[\]);**

//把编码转化为字符串可以使用 new String(byte[]);
            s2=new String(bytes);

##### char\[\] toCharArray() #####

*  将字符串转化为字符数组,并把字符数组的首地址返回

String s3=new String("qwertyuiopasdfghjklzxcvbnm");
            //toCharArray()方法可以将字符串转化为字符数组
            char[] chars=s3.toCharArray();

**当然也可以通过有参构造的方法将字符数组转化为字符串**

Arrays.sort(chars);//这里对字符数组进行了排序处理
            //new String(char[]);
            s3=new String(chars);
            System.out.println(s3);
    结果:abcdefghijklmnopqrstuvwxyz

String s="abcdefg";

先定义一个字符串

##### int length(); #####

*  获取字符串长度

System.out.println(s.length());//结果为7

##### char charAt(int index) #####

*  获取index位置上的字符

System.out.println(s.charAt(2));//结果为c

**在java没有输入字符的方法,我们可以节约这个方法来实现字符的输入**

Scanner in=new Scanner(System.in);
    String str= in.next;
    char c=str.charAt(0);//读取字符串第一个

##### int indexOf(int ch) #####

*  查找ch字符,如果查到返回索引,如果未查到,返回一个负数

System.out.println(s.indexOf('a'));//结果为0

##### int indexOf(String str) #####

*  查找str字符串,如果查到返回首字母的索引,如果未查到返回一个负数

System.out.println(s.indexOf("cd"));//结果为2

##### int index(int ch/String str,int fromIndex) #####

*  查找字符ch或字符串str,从fromIndex位置开始查找,返回

System.out.println(s.indexOf("ef", s.indexOf('e')));//结果为4

##### String substring(int start); #####

*  表示从start处截取字符串,将这个新的字符串地址作为返回值

System.out.println(s.substring(2));//结果edefg

##### String substring(int start,int end); #####

*  表示从start开始,end结束之间的截取,不包括结尾

System.out.println(s.substring(0,2));//结果ab

#### 转化功能 ####

##### byte\[\] getByte(); #####

*  把字符串返回成编码数组//

##### char\[\] toCharArray(); #####

*  把字符串返回成字符数组,返回新的字符串,不改变原来字符串

String s5="abcdef";
            char[] chars1=s5.toCharArray();

##### static String valueOf(char\[\] chs) #####

*  把字符数组转化为字符串类型返回的是字符串首地址

String strings= String.valueOf(chars1);//把字符数组转化为字符串类
            System.out.println(strings);//结果为abcdef

##### String toLowerCase(); #####

*  把字符串改为小写,返回新的字符串,不改变原来字符串

String s6="ABCD";
    System.out.println(s6.toLowerCase());//结果:abcd

##### String toUpperCase(); #####

*  把字符串改为大写,返回新的字符串,不改变原来字符串

String s7="abcd"
    System.out.println(s7.toUpperCase());//结果ABCD

##### String concat(String str); #####

*  把字符串str连接到对象字符串,返回新的字符串,不改变原来字符串

String s8="abc";
    System.out.println(s8.concat("def"));//结果abcdef

##### String\[\] split(分割符) #####

*  (分割符)

String s9="ab;cd;efg";
     String []strings1 =s9.split(";");
     System.out.println(Arrays.toString(strings1));//结果[ab,cd,efg]

##### String replace(char old,char new); #####

*  old字符被new字符替换,返回新的字符串,不改变原来字符串

String s10="abcDEF";
    System.out.println(s10.replace('a', 'A'));
    System.out.println(s10);//结果:AbcDEF;

##### String replace(String old,String new); #####

*  old字符串被new字符串替换,返回新的字符串,不改变原来字符串

System.out.println(s10.replace("ab", "AB"));//若无法匹配到目标字符串则不会替换

##### String replaceAll(String regex, String replacement); #####

*  基本功能类似于String replace(String old,String new);

##### replaceFirst(String regex, String replacement); #####

*  替换第一个目标字符串

##### public class StringUtil(自己定义工具类) #####

.out.println(Arrays.toString(strings1));//结果\[ab,cd,efg\]

#### String replace(char old,char new);
    
    - old字符被new字符替换,返回新的字符串,不改变原来字符串
    
    ```java
    String s10="abcDEF";
    System.out.println(s10.replace('a', 'A'));
    System.out.println(s10);//结果:AbcDEF;