⭐Java——常用类

一、包装类 Wrapper

针对八种基本数据类型 相应的引用类型——包装类
有了类的特点,就可以调用类中的方法

基本数据类型 包装类
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double

红色的包装类的父类都是 Number


包装类和基本数据的转换

装箱:基本类型 -> 包装类型
拆箱:包装类型 -> 基本类型
在jdk5以后含自动装箱和拆箱方式
自动装箱底层调用的是valueOf方法,比如Integer.valueOf( )


转换的代码演示

package com.ylxstudy.wrapper_;

/**
* @author 杨乐昕
* @version 1.0
*
* 演示 Integer 的 装箱和拆箱
*/
public class Integer01 {
    public static void main(String[] args) {
        //手动装箱
        int n1 = 100;
        Integer integer = new Integer(n1);//第一种方式
        Integer integer1 = Integer.valueOf(n1);
        
        //手动拆箱
        int i = integer.intValue();
        System.out.println(i);
        
        System.out.println("===我是分割线===");
        //自动装箱
        int n2 = 200 ;
        Integer integer2 = n2;//底层使用的是 Integer.valueOf()
        
        //自动拆箱
        int n3 = integer2;//底层使用的是 integer2.intValue()
        
    }
}

其他包装类的转换一样

包装类 相互转换 String

package com.ylxstudy.wrapper_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class WrapperVSString {
    public static void main(String[] args) {
        //包装类(Integer)-》String
        Integer i = 100 ;
        //        方式一
        String str = i+ "";
        //以Integer 类型的 i作为原始的数据,加上双引号后,变成字符串,对原先的i
        //的类型没有改变
        //        方式二
        String str2 = i.toString();
        //        方式三
        String str3 = String.valueOf(i);
        
        //        String -> 包装类
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        Integer i3 = new Integer(str4);//构造器
        
        System.out.println("ok" );
    }
}

关于包装类的面试题

面试题一

package com.ylxstudy.wrapper_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class WrapperExercise02 {
    public static void main(String[] args) {
        WrapperExercise02 wrapperExercise02 = new WrapperExercise02();
        wrapperExercise02.method1();
    }
    public void method1(){
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false
        //new对象,对于对象的 == 符号判断,判断的是地址
        
        Integer m = 1;//底层是Integer.valueOf(1)
        Integer n = 1;//底层是Integer.valueOf(1)
        System.out.println(m == n);//true
        //Integer.valueOf()的源码是
        /*
        *public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
        }
        *
        * IntegerCache.cache[i + (-IntegerCache.low)]是一个数组,在类加载的
        * 时候就加载好了
        *
        * i >= IntegerCache.low && i <= IntegerCache.high
        * 这是一个范围IntegerCache.low = -128 , IntegerCache.high = 127
        * 当在这个范围的时候,就直接返回,否则就new Integer(xx)
        * */
        
        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);//false
        //超出范围,所以是new 对象,判断的是对象的地址,结果输出false
    }
}

面试题二

package com.ylxstudy.wrapper_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class WrapperExercise03 {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//false,只要是new就是不同对象
        
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//false
        
        Integer i5 =127;
        Integer i6 = 127;
        System.out.println(i5 == i6);//true
        
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//false
        
        Integer i9 = 127 ;//从IntegerCache数组中取出来的
        Integer i10 = new Integer(127);
        System.out.println(i9 == i10);//false
        //==========================================================================
        Integer i11 = 127 ;
        int i12 = 127;
        //只要有基本数据类型,== 判断就是值,不是地址
        System.out.println(i11 == i12);//true
        
        Integer i13 = 128;
        int i14 = 128;
        //只要有基本数据类型,== 判断就是值,不是地址
        System.out.println(i13 == i14);//true
        
    }
}

二、⭐String 类

  1. String 对象用于保存字符串,也就是一组字符序列
  2. “jack”字符串常量,双引号括起来的字符序列
  3. 字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节
  4. String 类有很多的构造器,构造器的重载
    常用的构造器的有:
    String s1 = new String ();
    String s2 = new String (String original);
    String s3 = new String (char[] a);
    String s4 = new String (char[] a,int startIndex,int count);
    String s5 = new String (byte[] b);
  5. Serializable:String 实现了Serializable接口,说明String 可以串行化
    Comparable:String 实现了Comparable接口,说明String对象可以比较
  6. String 是final类,不能被其他的类继承
  7. String 有属性 private final char value[]; 用于存放字符串内容
  8. 一定要注意:value是一个final类型,不可以修改:即指的是value不能指向新的地址,但是单个字符内容可以修改可以变化
package com.ylxstudy.string_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class String01 {
    public static void main(String[] args) {
        /*
        * 1.String 对象用于保存字符串,也就是一组字符序列
        * 2.“jack”字符串常量,双引号括起来的字符序列
        * 3.字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节
        * 4.String 类有很多的构造器,构造器的重载
        *   常用的构造器的有:
        *   String s1 = new String ();
        *   String s2 = new String (String original);
        *   String s3 = new String (char[] a);
        *   String s4 = new String (char[] a,int startIndex,int count);
        *   String s5 = new String (byte[] b);
        * 5.Serializable:String 实现了Serializable接口,说明String 可以串行化
        Comparable:String 实现了Comparable接口,说明String对象可以比较
        * 6.String 是final类,不能被其他的类继承
        * 7.String 有属性 private final char value[]; 用于存放字符串内容
        * 8.一定要注意:value是一个final类型,不可以修改,:即指的是value不能指向新的地址
        *   但是单个字符内容可以修改可以变化
        *
        * */
        String name = "jack";
        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'h';
        //value = v2 ;是错误的,不可以修改value地址
        
    }
 }

String对象有两种创建方式
方式一:String s = “ylx”;
方式一先从常量池查看是否有"ylx"数据空间,如果有,直接指向;如果没有,则重新创建,然后再指向,s最终指向的是常量池的空间地址
方式二:String s1 = new String(“ylx”);// 调用构造器
方式二先再堆中创建空间,里面维护了value属性,指向常量池的ylx空间。
如果常量池没有ylx,重新创建,如果有,直接通过value指向。最终指向的是
堆中的空间地址

package com.ylxstudy.string_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise01 {
    public static void main(String[] args) {
        //两种创建String对象的区别
        String s = "ylx";//直接赋值
        String s1 = new String("ylx");//调用构造器
        
        /*
        * 1.方式一先从常量池查看是否有"ylx"数据空间,如果有,直接指向;如果没有,
        *   则重新创建,然后再指向,s最终指向的是常量池的空间地址
        * 2.方式二先再堆中创建空间,里面维护了value属性,指向常量池的ylx空间。
        *  如果常量池没有ylx,重新创建,如果有,直接通过value指向。最终指向的是
        *  堆中的空间地址
        * */
        
        String a = "abc";
        String b = "abc";
        System.out.println(a.equals(b));//根据源码,判断的是a和b之间的内容相等返回true
        //String重写了Object的equals方法
        /*
        * public boolean equals(Object anObject) {
        if (this == anObject) {
        return true;
        }
        if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = 0;
        while (n-- != 0) {
        if (v1[i] != v2[i])
        return false;
        i++;
        }
        return true;
        }
        }
        return false;
        }
        * */
        System.out.println(a == b);//true
        //a在常量池中查看有没有"abc",没有之后创建,a指向该"abc"的地址
        //b在常量池中查看有没有"abc",发现有之后,b直接指向“abc”的地址
        //所以两个判断的是地址是否相同,结果是相同的
    }
}

intern()方法 : 如果常量池中包含一个等于此String对象的字符串,用equals(Object)方法确定,有则返回池中的字符串地址,否则将String 对象添加到池中,并返回此String对象的引用

package com.ylxstudy.string_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise03 {
    public static void main(String[] args) {
        String a = "ylx";
        String b = new String("ylx");
        //intern()方法,如果常量池中包含一个等于此String对象的字符串,
        // 用equals(Object)方法确定,则返回池中的字符串
        //否则将String 对象添加到池中,并返回此String对象的引用
        //!!!b.intern()方法最终返回的是常量池的地址(对象)
        System.out.println(a == b.intern());//地址相同true
        System.out.println(b == b.intern());
        //b是指向堆中的地址,和常量池的地址不一样,返回false
        
    }
}

字符串特性

一、

package com.ylxstudy.string_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise08 {
    public static void main(String[] args) {
        String a = "hello";
        String b = "abc";
        String c = a + b;
        //先创建一个StringBuilder sb = new StringBuilder();
        //先执行sb.append("hello")
        //再执行sb.append("abc")
        //String c = sb.toString()
        //最后其实是c指向堆中的对象(String)value[]->"helloabc"
    }
}

这里创建了三个对象
底层StringBuilder sb = new StringBuilder();
sb.append(a) 和 sb.append(b)
sb是在堆中,并且append是在原来的字符串的基础上追加的

❗❗重要规则:
String c1 = “ab” + “cd”; 常量相加,看的是常量池
String c2 = a + b; 变量相加,看的是堆中

二、

package com.ylxstudy.string_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise09 {
    public static void main(String[] args) {
        String s1 = "ylxstudy";//指向池中的ylxstudy
        String s2 = "java" ;//指向池中java
        String s5 = "ylxstudyjava";//指向池中的ylxstudyjava"
        String s6 = (s1 + s2).intern();
        //s6接收到的是s1 + s2常量池的内容ylxstudyjava返回的地址
        
        System.out.println(s5 == s6);//所以这里地址相同,true
        System.out.println(s5.equals(s6));//地址相同,内容也相同,true
    }
}

三、
String 类的属性是final类型的,当发生改变时,指向也会发生改变
每次调用一次方法就创建一个新的对应方法的栈空间

package com.ylxstudy.string_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise10 {
    public static void main(String[] args) {
        Test1 ex = new Test1();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str + " and ");//javaand
        System.out.println(ex.ch);//hava
    }
}
class Test1 {
    String str = new String("ylx");
    final char[] ch = {'j', 'a', 'v', 'a'};
    public void change (String str,char ch[]){
        str = "java";
        ch[0] = 'h';
    }
}

String常用方法

String类是保存字符串常量的
每次更新都需要重新开辟空间,效率较低。
因此Java设计者提供了StringBuilder和StringBuffer
来增强String的功能并提高效率

怎么用就可以了
equals是区分大小写的;equalsIgnoreCase是忽略大小写的
“ylx”.length返回字符串的长度


indexOf: 从左向右索引
String s1 = “sjineu@jj”
int index = s1.indexOf(‘@’);


LastIndexOf: 从左向右索引
String s1 = “sjineu@jj@”
int index = s1.LastIndexOf(‘@’);
返回的是最后一个@ 的索引,前面出现@不取,只取最后一个
int index1 = s1.LastIndexOf(“sj”);
返回的是第一次出现该字符串的第一个字符的索引。0


substring
String name = “hello,张三”;
//下面的name.substring(6),从索引6开始截取后面的所有内容
sout(name.substirng(6));
//name.substirng(2,5)从索引第二个开始截取,截取到索引的5-1=4的位置(左闭右开)
sout(name.substring(2,5));


toUpperCase:将字符串全部转化为大写
toLowerCase:将字符串全部转化为小写

package com.ylxstudy.string_;

/**
* @author 杨乐昕
* @version 1.0
*/
public class StringMethod02 {
    public static void main(String[] args) {
        //3.concat字符串并接
        String s1 = "贾宝玉 ";
        s1 = s1.concat(" 林黛玉 ").concat(" 薛宝钗 ").concat("together");
        System.out.println(s1);
        
        //4.replace替换字符串中的字符
        s1 = "杨乐昕 and 云来喜";
        //s1.replace() 方法执行之后,返回的结果才是替换过的,
        //注意对s1是没有任何影响的
        s1 = s1.replace("杨乐昕","ylx");
        System.out.println(s1);
        
        //5.split 分割字符串
        String[] split;
        String poem = "E:\\AAA\\BBB&&nn";
        //如果分割有特殊字符,需要假如特殊字符
        split = poem.split("\\\\");//????
        for (int i= 0;i < split.length;i++){
            System.out.println(split[i]);
        }
        
        //6.toCharAarray 转化成字符数组
        String s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0;i<chs.length;i++){
            System.out.println(chs[i]);
        }
        //7.compareTo 比较两个字符串的大小,如果前者大,则返回正数
        //后者大则返回负数;如果相等,返回0
        //细节:
        //如果长度相同,并且每个字符也相同,就返回0
        //如果长度相同或者不相同,但是在进行比较时,可以区分大小就返回
        //(某个字符的ASCII码减去另外一个的码)
        //如果前面的部分都相同,就返回,str1.len - str2.len
        String a = "jak";
        String b = "jack";
        System.out.println(a.compareTo(b));//a.len - b.len = -1
        
        //8.format 格式字符串
        String name = "yanglx";
        int age = 21 ;
        double score = 90 / 3;
        char gender = '男';
        
        String formatStr = "我的名字是%s 年龄是%d 成绩是%.2f 性别是%c ";
        String info = String.format(formatStr,name,age,score,gender);
        System.out.println("info=" + info);
    }
}

三、⭐StringBuffer类

java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删,很多方法和String 相同,但StringBuffer是可变长度的。(用在多线程)
StringBuffer是一个容器

  1. StringBuffer的直接父类是AbstractStringBuilder
  1. StringBuffer 实现了 Serializable 即StringBuffer的对象可以串行化
  2. 在父类中 AbstractStringBuilder 有属性 char[] value,是存放StringBuffer对象字符串内容的
    不是final,该value数组存放字符串内容,存放在堆中,而不是常量池
  3. StringBuffer是一个final类,不能被继承
  4. 因为StringBuffer 的字符内容是存放在char[] value,所有在变化(增加/删除)
    不用每次都更换地址(即不是每次创建新对象),所以效率较高

String 和 StringBuffer 的比较区别

  1. string保存的是字符串常量,里面的值不能更改,每次String类的更新实际
    上是更改地址,效率较低
    String -> private final char value[]
  2. StringBuffer保存的是字符串变量,里面的值可以更改,每次StringBuffer
    的更新实际上是更新内容,不用每次更新地址,效率较高;当value数组的空间
    不够的时候,StringBuffer有自己的一套扩容机制,value扩容之后,会返回一个
    全新的地址给value
    StringBuffer -> char[] value

StringBuffer的构造器

  1. StringBuffer()
    构造一个其中不带字符的字符串缓冲区,其初始值容量为16个字符
  1. StringBuffer(int capcity)
    通过构造器指定char[]大小
  1. StringBuffer(String str)
    构造一个字符串缓冲区,并将内容初始化为指定的字符串内容
    StringBuffer hello = new StringBuffer(“hello”);
    把当前传进去的字符串 的长度 加上 16,创建一个长度为“字符串长度+16”的char类型的数组

String 和 StringBuffer 的相互转换

package com.ylxstudy.stringbuffer_;

/**
* @author 杨乐昕
* @version 1.0
*      String 和 StringBuffer的相互转换
*/
public class StringBuffer02 {
    public static void main(String[] args) {
        //        String -> StringBuffer
        String str = "hello tom";
        //方式一使用构造器
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式二使用append方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);
        //============================================================
        //        StringBuffer -> String
        StringBuffer ylx = new StringBuffer("ylx");
        //方式一使用提供的toString方法
        String s = ylx.toString();
        //方式二使用构造器
        String s1 = new String(ylx);
    }
}

StringBuffer类的常用方法

增——append 追加
删——delete(start,end) 左闭右开
改——replace(start,end,string)
查——indexOf(string) 查找字符串的第一个字符的索引返回,没有返回-1
插——insert(位置,字符串) 找到索引为9的字符位置插入要插入的字符串,原来位置的字符串后移
获取长度——length 返回字符串的长度


四、⭐StringBuilder类

基本介绍

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

StringBuilder常用方法

StringBuilder和StringBuffer的方法是一样的,常用方法参考StringBuffer的常用方法


StringBuilder结构剖析

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

String StringBuffer StringBuilder之间的比较

  1. StringBuffer 和 StringBuilde非常类似,均可待变可变的字符序列,而且方法也一样
  1. String: 不可变字符序列,效率低,但是复用率搞高
  2. StringBuffer: 可变字符序列,效率较高(增删),线程安全
  3. StringBuilder: 可变字符序列,效率最高,线程不安全
  4. String使用注意说明
    string s = “a”;//创建一个字符
    s += “b”;//
    实际上原来的“a”字符串对象已经丢弃了,现在又产生了一个字符串s+“b”,也就是“ab”,如果多次执行串内容的操作,会导致大量的副本字符串对象存留在内存中,降低效率,如果这样的操作放在循环中,会极大的影响程序的性能

结论:如果使用String做大量的修改,不要使用String


String StringBuffer StringBuilder 的选择

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

五、Math类

用于执行基本数学运算,都是静态方法,直接引用

常用数学静态方法
abs 绝对值
pow 求幂
ceil 向上取整
floor 向下取整
round 四舍五入
sqrt 求开方
random 求随机数 int num = (int)(Math.random()*(b-a+1)+a)
min( , ) 最小值
max( , ) 最大值


六、Arrays类

方法一:toString()

package com.ylxstudy.arrays_;

import java.util.Arrays;

/**
* @author 杨乐昕
* @version 1.0
*      使用Array类自带的遍历方法 Arrays.toString方法 显示数组
*/
public class ArraysMethod01 {
    public static void main(String[] args) {
        Integer[] integers = {1,20,98};
        //使用Array类自带的遍历方法 Arrays.toString方法 显示数组
        System.out.println(Arrays.toString(integers));
    }
}

方法二:sort排序(自然排序和定制排序)

自然排序

是从小到大

package com.ylxstudy.arrays_;

import java.util.Arrays;
import java.util.Comparator;

/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1,-1,7,0,89};
        //        //传统排序:冒泡排序 (从小到大)
        //        int temp = 0;//初始化一个变量 用于交换变量
        //        for (int i = 0;i < arr.length-1 ; i++){
        //            for (int j = 0 ; j < arr.length-1-i ; j++){
        //                if(arr[j] > arr[j+1]){
        //                    temp = arr[j];
        //                    arr[j] = arr[j+1];
        //                    arr[j+1] = temp;
        //                }
        //            }
        //        }
        //        for (int i = 0;i< arr.length ;i++){
        //            System.out.print(arr[i] + " ");
        //        }
        //默认排序
        Arrays.sort(arr);
        System.out.println("=====排序之后的====");
        System.out.println(Arrays.toString(arr));
    }
}

⭐定制排序

结合了 接口编程 多态的动态绑定 匿名内部类 内容

package com.ylxstudy.arrays_;

import java.util.Arrays;
import java.util.Comparator;

/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1,-1,7,0,89};
        
        //定制排序
        /*
        * 1.数组是引用类型,所以通过sort排序后,会直接影响到 实参 arr
        * 2、sort是重载的,也可以通过传入一个接口 Comparator 实现定制排序
        * 3.调用定制排序时,传入两个参数
        *   (1)要排序的数组 arr
        *   (2)实现了Comparator接口的匿名内部类,要求实现 compare方法
        *
        * 源码分析
        * 1.Arrays.sort(arr,new Comparator(){...};)
        * 2.最终到TimSort类的private static  void binarySort(T[] a, int lo, int hi, int start,
        Comparator c)
        *3.执行到binarySort方法的代码,会根据动态绑定机制,c.compare()执行我们传入的匿名内部类的compare()
        * binarySort()方法的一段关键代码
        * while (left < right) {
        int mid = (left + right) >>> 1;
        if (c.compare(pivot, a[mid]) < 0)
        right = mid;
        else
        left = mid + 1;
        }
        * 4.
        * ...new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
        Integer i1 = (Integer)o1;
        Integer i2 = (Integer)o2;
        
        return i2 -i1;//大于0还是小于0决定排序的顺序
        }
        * 5.public int compare(Object o1,Object o2) 返回的值 > 0 ,还是<0
        *   会影响整个排序结果,还充分表现了 接口编程+动态绑定+匿名内部类 的综合使用
        *   将来的底层框架和源码的使用方式,会非常常见
        * */
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer)o1;
                Integer i2 = (Integer)o2;
                
                return i2 -i1;//大于0还是小于0决定排序的顺序
            }
        });
        System.out.println("====定制排序=====");
        System.out.println(Arrays.toString(arr));
    }
}

方法三:binarySearch()方法

通过二分搜索法进行查找,要求必须排好序

package com.ylxstudy.arrays_;

import java.util.Arrays;

/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod03 {
	public static void main(String[] args) {
		Integer[] integers = {1,34,55,123,445};
		//使用Arrays类的binarySearch方法进行查找
		//当查找的数字不在数组里面时,会通过要查找数字的大小在数字的其他元素中
		//应该存放的位置,返回存放位置的索引
		//int index = Arrays.binarySearch(integers,45);
		//通过系统的比较,应该是在34 和 55 之间,根据索引,返回的是 ”2“+1 = 3
		int index = Arrays.binarySearch(integers,34);
		System.out.println("index = " + (index+1));
		
	}
}

方法四:copyOf()方法

复制数组

package com.ylxstudy.arrays_;

import java.util.Arrays;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class ArraysMethod04 {
    public static void main(String[] args) {

        Integer[] arr4 = {12,23,44,45,23};
        //从arr4数组中复制arr4.length个元素给 arrCopy
        //如果要拷贝的长度大于被拷贝的数组的长度 就在多出来的元素位置添加一个null
        //如果拷贝的长度<0 就会抛出异常
        Integer[] arrCopy = Arrays.copyOf(arr4,5);
        System.out.println(Arrays.toString(arrCopy));
    }
}

方法五:fill() 填充

替换数组里面的元素

package com.ylxstudy.arrays_;

import java.util.Arrays;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class ArraysMethod05 {
    public static void main(String[] args) {
        //数组的填充fill
        Integer[] arr5 = {12,23,33};
        Arrays.fill(arr5,66);
        System.out.println(Arrays.toString(arr5));
    }
}

方法六:equals()

比较两个数组的元素是否一样

package com.ylxstudy.arrays_;

import java.util.Arrays;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class ArraysMethod06 {
    public static void main(String[] args) {
        Integer[] arr6 = {11,22,33};
        Integer[] arr61 = {11,22,33};
        //比较两个数组的元素是否一样
        boolean equals = Arrays.equals(arr6,arr61);
        System.out.println(equals);
    }
}

方法七:aslist()

将一个数组的值,转为集合list

package com.ylxstudy.arrays_;

import java.util.Arrays;
import java.util.List;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class ArraysMethod07 {
    public static void main(String[] args) {
        List<Integer> asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList= " + asList);
    }
}

七、System类

方法一:exit退出当前的程序

exit(0) 参数0表示以正常状态退出

public class System_ {
    public static void main(String[] args) {
        System.out.println("ok1" );
        exit(0);
        System.out.println("ok2");
    }
}

方法二:arraycopy( )

int[] src = {1,2,3};
int[] dest= new int[3];
System.arraycopy(src,0,dest,0,3);
System.out.println(Arrays.toString(dest));

arraycopy(x,x,x,x)
第一个参数表示要复制的原数组
第二个参数表示从原数组的第几个位置开始复制
第三个参数表示复制到哪个数组去
第四个参数表示从哪个位置开始粘贴
第五个参数表示复制原数组的多少个元素,以数组的长度决定

方法三:currentTimeMillens()

返回当前时间距离1970-1-1 的毫秒数

方法四:gc()垃圾回收机制

八、BigInteger类

当我们编程的中,需要处理很大的整数时,long不够用,可以使用BigInteger的类来搞定

package com.ylxstudy.biginteger_;

import java.math.BigInteger;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class BigInteger_ {
    public static void main(String[] args) {
        //long 不够存储这么大的数字,使用,BigInteger类来存储
//        long num = 127777172774727277777l;
        //传进去的值 要用双引号给括起来,源码是String类型的
        //把数据当成字符串处理完之后,在转为BigInteger
        BigInteger bigInteger = new BigInteger("127777172774727277777");
        BigInteger bigInteger1 = new BigInteger("100");
        //通过使用BigInteger类的方法来实现 加减乘除
        //加
        BigInteger add = bigInteger.add(bigInteger1);
        System.out.println(add);
        //减
        BigInteger subtract = bigInteger.subtract(bigInteger1);
        System.out.println(subtract);
        //乘
        BigInteger multiply = bigInteger.multiply(bigInteger1);
        System.out.println(multiply);
        //除
        BigInteger divide = bigInteger.divide(bigInteger1);
        System.out.println(divide);
    }
}

九、BigDecimal类

当我们要保存一个精度很高的数字时,double不够用
加法 减法 乘法 和BigInteger类的用法是一样的

package com.ylxstudy.bigdecimal_;

import java.math.BigDecimal;
import java.math.BigInteger;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class BigDecimal_ {
    public static void main(String[] args) {
//        double D = 1223.44444334343433434434343434343434343434d;
        BigDecimal bigDecimal = new BigDecimal("123.444455556666677");
        BigDecimal bigDecimal1 = new BigDecimal("1.2");
        //除法
//        BigDecimal divide = bigDecimal.divide(bigDecimal1);
//        System.out.println(divide);//会抛出异常,原因是,除不尽
        //我们要在bigDecimal1 后面加上 BigDecimal.ROUND_CEILING
        //如果有无限循环的小数,就会保留 和分子 一致的精度
        BigDecimal divide = bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING);
        System.out.println(divide);
    }

}

十、Date类

SimpleDateFormat 的日期格式
⭐Java——常用类_第1张图片

package com.ylxstudy.date_;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class Date01 {
    public static void main(String[] args) throws ParseException {
        //获取当前的系统时间
        //这里的Date是java.util包下的
        //默认的输出日期格式是国外的格式
        Date date = new Date();
        System.out.println(date);
        //可以通过指定的毫秒数得到时间
        Date date1 = new Date(878724);
        System.out.println(date1);


        //创建SimpleDateFormat对象,可以指定相应的格式,要按照API文档要求的写
        //这里的格式要规定好
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        //SimpleDateFormat类下的 format() 方法是将日期转换成指定格式的字符串
        String format = sdf.format(date);
        System.out.println(format);

        //可以把一个格式化的String 转成 对应的 Date
        //得到的date仍然在输出时,还是以国外的形式输出,希望以规定的格式输出,需要转换
        //把String -> Date,使用的sdf格式需要和你给的String 的格式一样,否则就会抛出异常
        String s = "1996年01月01日 10:20:30 星期一";

        Date parse = sdf.parse(s);
        System.out.println("parse = " + sdf.format(parse));
    }
}

十一、Calendar类

package com.ylxstudy.date_;

import java.util.Calendar;

/**
 * @author 杨乐昕
 * @version 1.0
 */
public class Calendar_ {
    public static void main(String[] args) {
        //Calendar 的构造器是受保护的,不能直接创建实例,要通过get方法获取
        //抽象类,构造器是受保护的,通过,getInstance()来获取实例
        //提供大量的方法和字段提供
        //1.获取一个日历对象
        Calendar c = Calendar.getInstance();
        //2.获取日历对象的某个日历字段
        System.out.println("年," + c.get(Calendar.YEAR));
        //3.获取月时 要 加一 ,因为Calendar返回月的时候,是按照从0 开始编号的
        System.out.println("月," + (c.get(Calendar.MONTH) + 1));
        //4.日
        System.out.println("日," + c.get(Calendar.DAY_OF_MONTH));
        //没有提供对应格式化的类,需要自己组合
        System.out.println(c.get(Calendar.YEAR) + "年"
                + (c.get(Calendar.MONTH) + 1) + "月"
                + c.get(Calendar.DAY_OF_MONTH) + "日");
        //按照24小时制
        System.out.println(c.get(Calendar.YEAR) + "年"
                + (c.get(Calendar.MONTH) + 1) + "月"
                + c.get(Calendar.DAY_OF_MONTH) + "日"
                + c.get(Calendar.HOUR_OF_DAY) + ":"
                + c.get(Calendar.MINUTE) + ":"
                + c.get(Calendar.SECOND));
        //不是线程安全的,
    }

以上内容皆是本人通过韩顺平老师视频Java零基础学习的笔记,如果有侵权,请联系我删除❗❗❗

你可能感兴趣的:(笔记,java,面试,jvm)