Java常用类(含常用方法)==具体内容看摘要==

包装类

从Byte开始到Double所以黑字的父类都是Number

包装类和基本数据的转换

演示包装类和基本数据类型的相互转换,这里以int和 Integer演示。

1. jdk5前的手动装箱和拆箱方式，装箱:基本类型->包装类型，反之，拆箱
2. jdk5以后(含jdk5)的自动装箱和拆箱方式
   3)自动装箱底层调用的是valueOf方法，比如Integer.valueOf(0
   以Integer和int 的相互转换举例

public class Test {
    
    
    public static void main(String[] args) {
    
    
        //JDK5.0以前采用手动装箱拆箱
        int n1=100;
        //手动装箱
        Integer integer=new Integer(n1);
        Integer integer1= Integer.valueOf(n1);
        //手动拆箱
        int n2=integer.intValue();
        //JDK5.0含5.0以后使用自动装拆箱
        Integer integer2=n1;
        //自动拆箱
        int n3=integer2;

    }
}

包装类和String 类型的基本转换

以Integer和String 相互转换举例：

public class Test {
    
    
    public static void main(String[] args) {
    
    
        //包装类和String 的互相转换
        Integer i=100;
        //包装类--->String 方法一：
        String string =i+"";
        //方法二：
        String string1 =i.toString();
        //方法三：
        String string2= String.valueOf(i);//valueOf（）括号里面放 Object object
        //String ----->包装类
        String string3="1234";
        Integer integer1=Integer.parseInt(string3);//parseInt()得到int ，再自动装箱为包装类
        Integer integer2=new Integer(string3);//构造器
    }
}

Integer类和Character类的常用方法

经典面试题

源码解读：
只要是 new Integer（）出来的一定是不同对象
只要有基本数据类型判断值是否相等

String类

特别注意value[ ]是一个final类型，不可修改（这句话很容易搞混），不是说你字符数组value[ ]中的内容不能变化，
而是value不能指向新的地址，比如下面的value=v2就指向新地址

String对象的创建方法和String的内存布局

法一：String s=“hsp”;
法二：String s=new String (“hsp”);

intern（）函数

最终返回的是常量池中对象的地址
调用intern（）函数，假如常量池中已经有了等于String对象的字符串则返回池中的字符串
否则就创建一个String对象添加到池中，并返回该对象的引用

字符串特性及练习题

String a=“abc”+"hello"常量相加和String a=b+c变量相加（四部怎么走？）的区别

创建了两个对象

只创建了一个对象

创建了三个对象
String a=“abc”+“hello”;常量相加：看得是池
String a=b+c;变量相加看得是堆

注意创建String c的四部曲是怎么走的，注意变量相加和常量相加的区别

public class String_Test {
    
    
    public static void main(String[] args) {
    
    
        String a="hello";
        String b="abc";
        //debug得出步骤
        //1、创建一个 StringBuilder sb=new StringBuilder();
        //2、sb.append("hello");
        //3、sb.append("abc");
        //4、String c=sb.toString();
        最后其实是c指向堆中的对象(String) value[] ->池中"helloabc"
        String c=a+b;
        String d="helloabc";
        System.out.println((c==d));
        String e="hello"+"abc";
        System.out.println(d==e);//e指向常量池

    }
}

结合传参机制，考虑创建String的内存布局

！！！重点这题做错了
考到了前面的基本数据类型和引用类型传参机制（可以看Java面向对象编程（基础）篇内容）

String常用方法

equals //区分大小写，判断内容是否相等
equalslgnoreCase//忽略大小写的判断内容是否相等
length//获取字符的个数，字符串的长度
indexOf//获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
lastIndexOf//获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring（） //截取指定范围的子串
substring（int index）//从index开始截取字符串剩余所有字符
substring（int start,int end）//注意左闭右开
trim//去前后空格
charAt:获取某索引处的字符,注意不能使用Str[index]这种方式.
toUpperCase//转化为大写
toLowerCase
concat//拼接
replace（char oldChar, char newChar）替换字符串中的字符
split 返回一个数组，分割字符串,对于某些分割字符，我们需要转义比如| \等
案例: String poem =“锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦”;和文件路径.
compareTo //比较两个字符串的大小
compareTo方法详解：

 public int compareTo(String anotherString) {
    
    
        //len1：当前字符串长度
        int len1 = value.length;
        //len2：参数字符串长度
        int len2 = anotherString.value.length;
        //len1和len2两者最小值
        int lim = Math.min(len1, len2);
        //分别转为字符数组
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        //比较逻辑
        while (k < lim) {
    
    
            char c1 = v1[k];
            char c2 = v2[k];
            //字符不同，则返回两字符的ASCII 码的差值
            if (c1 != c2) {
    
    
                return c1 - c2;
            }
            k++;
        }
        //相同则返回两字符长度差值
        return len1 - len2;
    }

toCharArray l/转换成字符数组
format //格式字符串,%s字符串%c字符%d整型%.2f 浮点型案例,将一个人的信息格式化输出.

StringBuffer

==注意StringBuffer存放字符串的数组char [ ]value 不再是final属性的了，所以存放在堆中
String 存放字符串的数组final char [ ] value 是final属性的，所以存放在常量池里 ==

StringBuffer的构造方法

1、StringBuffer stringBuffer = new StringBuffer();//默认创建一个大小为16的 char[],用于存放字符内容
2、通过构造器指定 char[]大小
StringBuffer stringBuffer1 = new StringBuffer(100);
3、源码规定：通过给一个String创建StringBuffer，char[ ]大小就是 str.length() + 16
StringBuffer hello = new StringBuffer(“hello”);

String与StringBuffer的相互转换

String—>StringBuffer

String s = “hello”;
方式1:
StringBuffer b1 = new StringBuffer(s);
方式2:
StringBuffer b2 = new StringBuffer();
b2.append(s);

StringBuffer->String

方式1:
String s2 = b1.toString();//b1 [StringBuffer]
方式2:
String s3 = new String(b1);

StringBuffer类常用方法

1)增append
2)删delete(start,end)
3)改replace(start,end,string)
//将start----end间的内容替换掉,不含end
4)查indexOf //查找子串在字符串第1次出现的索引,如果找不到返回-1
5)插insert（int index）//在索引为index位置插入字符串，并且索引所在位置的字符需要自动往后移
6)获取长度length

练习题

利用StringBuffer常用方法给大型数字加上","

public class Class_StringBuffer {
    
    
    public static void main(String[] args) {
    
    
        //先输入没有","的数据
        System.out.println("请输入数据");
        Scanner scanner = new Scanner(System.in);
        String n;
        n=scanner.next();
        //将String 转为StringBuffer
        StringBuffer sb=new StringBuffer(n);
        //首先找到"."的位置,准确来说是找到"."的最后索引位置
        int index=sb.lastIndexOf(".");
        //在"."的前三位加上","
        for(int i=index-3;i>0;i-=3){
    
    
            sb.insert(i,",");
        }
        System.out.println(sb);
    }
}

StringBuilder类

StringBuilder是一个可变的字符序列。此类提供一个与StringBuffer 兼容的API,但不保证同步(StringBuilder不是线程安全)。
该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。
如果可能，建议优先采用该类因为在大多数实现中，它比 StringBuffer 要快[后面测]。
在StringBuilder 上的主要操作是 append和 insert方法，可重载这些方法,以接受任意类型的数据。

注意点：（单线程使用）

1.StringBuilder继承 AbstractStringBuilder类
2.实现了Serializable ，说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)
3. StringBuilder 是final类，不能被继承
4.StringBuilder对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value;因此，字符序列是堆中
5. StringBuilder 的方法，没有做互斥的处理,即没有synchronized关键字,因此在单线程的情况下使用StringBuilder

String、StringBuffer、StringBuilder三类的区别

效率StringBuilder>StringBuffer>String
String、StringBuffer 和StringBuilder的比较

1. StringBuilder和 StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
2. String:不可变字符序列,效率低,但是复用率高。（在常量池中创建可以多次被对象引用）
3. StringBuffer:可变字符序列、效率较高(增删)、线程安全,看源码
4. StringBuilder:可变字符序列、效率最高、线程不安全
5. String使用注意说明:
   string s=“a”;//创建了一个字符串
   s += “b”;//实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b”(也就是"ab”)。
   如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。
   如果这样的操作放到循环中，会极大影响程序的性能=>结论:如果我们对String做大量修改,不要使用String

结论

1．如果字符串存在大量的修改操作，一般使用StringBuffer 或StringBuilder
2.如果字符串存在大量的修改操作，并在单线程的情况,使用 StringBuilder
3.如果字符串存在大量的修改操作，并在多线程的情况,使用 StringBuffer
4．如果我们字符串很少修改，被多个对象引用，使用String,比如配置信息等

Math类

1. abs绝对值

2. pow求幂

3. ceil向上取整

4. floor向下取整

5. round四舍五入（+0.5如何保留整数部分）

6. sqrt求开方

7. random求随机数（返回[0~1)的小数）
   如何获取[a，b]之间的整数，注意b也要能取到
   公式是：int num=（int）(Math.random()*(b-a+1)+a)
   

8. max求两个数的最大值

9. min求两个数的最小值
   

Arrays类

常见方法

1. toString返回数组的字符串形式Arrays.toString(arr)
2. sort排序(自然排序和定制排序) Integer arr[] = {1, -1,7,0, 893};
3. binarySearch通过二分搜索法进行查找，要求必须排好序
   int index = Arrays.binarySearch(arr, 3);找不到返回-（low+1）
4. copyOf 数组元素的复制
   Integer[] newArr = Arrays.copyOf(arr, arr.length);
   5)fill 数组元素的填充
   Integer[] num = new Integer[]={9,3,23};Arrays.fill(num,99);//用99替换原来的元素
   6)equals 比较两个数组元素内容是否完全一致boolean equals = Arrays.equals(arr, arr2);
5. asList 将一组值，转换成list
   List asList = Arrays.asList(2,3,4.5,6,1);
   System.out.println(“asList=” +asList);

sort()方法详解

​​​​第一种基本格式

Array.sort(数组名，起始下标，终止下标）(默认升序)
例子

import java.util.Arrays;

public class test {
    
    
	public static void main(String args[]) {
    
    
		int[] a ={
    
    1,8,6,9,4,7,6};
		Arrays.sort(a,0,a.length);
		for(int i : a){
    
    
			System.out.print(i+" ");
		}
	}
}

​​​​​​​​​​​​​​​​

第二种基本格式​

Arrays.sort(数组名)（默认升序，这种情况只适合数组已被初始化）

例子：

import java.util.Arrays;

public class test {
    
    
	public static void main(String args[]) {
    
    
		int[] a ={
    
    1,8,6,9,4,7,6};
		Arrays.sort(a);
		for(int i : a){
    
    
			System.out.print(i+" ");
		}
	}
}

第三种基本格式

源码：
底层BinarySort（）方法
​​
函数的基本格式
int compare (Object o1,Object o2);

传入参数的类型是java中的类
这时的sort函数的格式变成了：

Arrays.sort(数组名，起始下标，终止下标，new cmp());

返回值的基本方法：
int compare(Object o1, Object o2) 返回一个基本类型的整型 如果要按照升序排序， 则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数） 如果要按照降序排序 则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）

例子（就看第一个就行）
利用匿名内部类实现接口Comparator实现自定义排序

public class Sort {
    
    
    public static void main(String[] args) {
    
    
        Integer num []={
    
    1,4,3,5,2};//写成int 不行
        //自定义排序(匿名内部类实现接口Comparator,要求实现compare（）方法)
        Arrays.sort(num,new Comparator<Integer>(){
    
    
            @Override
            public int compare(Integer o1, Integer o2) {
    
    
                //这里是降序
                return o2-o1;//返回正负数决定升序还是降序
            }
        });
        System.out.println("排序后数组");
        System.out.println(Arrays.toString(num));
    }
}

没学会匿名内部类时用到蠢办法

​package qiuqiu;
import java.util.*;
import java.util.Arrays;
class node{
    
    
    int x;
}
class cmp implements Comparator<node>{
    
    
    public int compare(node a,node b){
    
    
        if(a.x<b.x)
            return 1;
        else if(a.x>b.x)
            return -1;
        else
            return 0;
    }
}
public class yun{
    
    
    public static void main(String args[]){
    
    
        node[] a = new node[10];
        Scanner cin = new Scanner(System.in);
        System.out.println("请输入10个整数：");
        int t=10,i=0;
        while(t>0){
    
    
            a[i] = new node();    //  这里不要漏掉，第19行只是创建10个node对象，这里才是创建具体的空间
            a[i].x=cin.nextInt();
            i++;
            t--;
        }
        Arrays.sort(a,0,a.length,new cmp());
        System.out.println("从小到大排序结果后：");
        for (node k :a){
    
    
            System.out.print(k.x+" ");
        }
        System.out.print("\n");
    }
}

System类

BigInteger和BigDecimal类

应用场景:

1. Biglnteger适合保存比较大的整型
2. BigDecimal适合保存精度更高的浮点型(小数)
   

Date类

第一代日期类Date

常用方法

Date d1 = new Date();1/获取当前系统时间，得到的是国外格式的时间
Date d2 = new Date(9234567);//通过指定毫秒数得到时间
System.out.println(d1.getTime（）);//获取某个时间对应的毫秒数
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日hh:mm:ss E”);
String format = sdf.format(d1); // format:将日期转换成指定格式的字符串,
最后格式：String s = “1996年01月01日10:20:30星期一”;
Date parse = sdf.parse(s);//将字符串s转换为日期类，格式是国外格式

第二代日期类Calendar

Calendar c= Calendar.getInstance();//创建日历类对象//比较简单，自由System.out.println©;
//2.获取日历对象的某个日历字段
System.out.printIn(“年:"+c.get(Calendar.YEAR));
System.out.printIn(“月:”+(c.get(Calendar.MONTH)+1));
System.out.println(“日:"+c.get(Calendar.DAY_OF_MONTH));
System.out.println(“小时:”+c.get(Calendar.HOUR));
System.out.println(“分钟:”+c.get(Calendar.MINUTE));
System.out.println(“秒:”+c.get(Calendar.SECOND));
Calender没有专门的格式化方法，所以需要程序员自己来组合显示
System.out.printIn(c.get(Calendar.YEAR)+“年”+(c.get(Calendar.MONTH)+1)+“月”+c.get(Calendar.DAY_OF_MONTH)+“日”);

第三代日期类

前面两代日期类的不足分析
JDK1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引Calendar类之后被弃用了。
而Calendar也存在问题是:
1)可变性:像日期和时间这样的类应该是不可变的。
2)偏移性:Date中的年份是从1900开始的，而月份都从0开始。
3)格式化:格式化只对Date有用，Calendar则不行。
4)此外，它们也不是线程安全的;不能处理闰秒等(每隔2天,多出1s)。

第三代日期类常见方法

1. LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日时分秒)JDK8加入
   LocalDate只包含日期,可以获取日期字段
   LocalTime只包含时间，可以获取时间字段
   LocalDateTime包含日期+时间，可以获取日期和时间字段案例演示[后ppt]:
   LocalDateTime ldt = LocalDateTime.now();//LocaIDate.now();//LocalTime.now
   System.out.println(ldt);
   ldt.getYear();ldt.getMonthValue();ldt.getMonth();ldt.getDayOfMonth();
   ldt.getHour();ldt.getMinute();ldt.getsecond()

DateTimeFormatter

DateTimeFormatter格式日期类类似于SimpleDateFormat
DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);
String str = dtf.format(日期对象);
案例演示:
LocalDateTime ldt = LocalDateTime.now();
//关于DateTimeFormatter的各个格式参数，需要看jdk8的文档.
DateTimeFormatter dtf = DateTimeFormatter.ofPattern(“yyy年MM月dd日HHDT时mm分钟ss秒”);
String strDate = dtf.format(ldt);
ldt.getHour();ldt.getMinute();ldt.getsecond();

Instant 时间戳

3. Instant时间戳类似于Date
   提供了一系列和Date类转换的方式Instant—>Date:
   Date date = Date.from(instant);Date------->Instant:
   lnstant instant = date.tolnstant();案例演示:
   lnstant now = Instant.now0;System.out.println(now);
   Date date = Date.from(now);
   lnstant instant = date.tolnstant();