1.java基础回顾常用类

一.java.lang包中的类不需要导包

1.特点：

　　java.lang包是java语言的核心，它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。

2. 8种基本类型初始化默认值：

注：char类型初始化默认值为null（也就是'u0000'）

Java中8种基本数据类型总结
序号	数据类型	大小/位	封装类	默认值	可表示数据范围
1	byte(位)	8	Byte	0	-128~127
2	short(短整数)	16	Short	0	-32768~32767
3	int(整数)	32	Integer	0	-2147483648~2147483647
4	long(长整数)	64	Long	0	-9223372036854775808~9223372036854775807
5	float(单精度)	32	Float	0.0	1.4E-45~3.4028235E38
6	double(双精度)	64	Double	0.0	4.9E-324~1.7976931348623157E308
7	char(字符)	16	Character	空	0~65535
8	boolean	8	Boolean	flase	true或false

3.其它类型默认值都是null

二.java类的使用

0. Object类：

特征：所有类的基类，即使不显示继承也会继承Object类并拥有Object类中的方法。

public final native Class<?> getClass()    //返回此 Object 运行时的类
 
public native int hashCode()    //返回对象的哈希码
 
public boolean equals(Object obj)    //判断其他对象与此对象是否“相等”
 
protected native Object clone() throws CloneNotSupportedException    //创建并返回此对象的一个副本
 
public String toString()    //返回对象的字符串表示
 
public final native void notify()    //唤醒在此对象监视器上等待的单个线程
 
public final native void notifyAll()    //唤醒在此对象监视器上等待的所有线程
 
public final native void wait(long timeout) throws InterruptedException    //使当前对象的线程等待 timeout 时长
 
public final void wait(long timeout, int nanos) throws InterruptedException    //使当前对象的线程等待 timeout 时长，或其他线程中断当前线程
 
public final void wait() throws InterruptedException    //使当前对象的线程等待 

1.Objects类：

/**
 * 1.Objects类：java.util.Objects
 * JDK1.7开始添加了一个工具类
 * 用于计算对象的hashcode，返回对象的字符串表示形式，比较两个对象等
 * 这些方法都是空指针安全的
 */
String s = null;
String s1 = "s1";

//报错：java.lang.NullPointerException，由于s为null所以不能调用任何方法
//System.out.println(s.equals(s1));

System.out.println(Objects.equals(s,s1));   //false

2.Date类：

/**
 * 2.Date类：日期时间类，java.util.Date
 * 精确到毫秒
 */
System.out.println(new Date());     //显示当前日期
System.out.println(new Date(1000000000L));   //将毫秒值转换为日期
System.out.println(new Date().getTime());   //将系统当前时间转换为毫秒显示
System.out.println(System.currentTimeMillis()); //返回系统当前时间以毫秒显示

3.DateFormat类：

/**
 * 3.DateFormat类：是时间/日期格式化的抽象类，java.text.DateFormat
 * 作用：
 *      格式化：日期-->文本，解析：文本-->日期
 * 成员方法：
 *      String format(Date date)：将日期转化为字符串
 *      Date parse(String source)：将字符串解析为日期
 *
 * 由于DateFormat类为抽象类，我们使用SimpleDateFormat类来使用
 * SimpleDateFormat构造方法：
 *      SimpleDateFormat(String pattern)
 * 参数：
 *      String pattern：传递的指定模式
 * 模式：区分大小写
 *      y  年，M 月，d 日，H 时，m 分，s 秒
 * 一般默认模式：
 *      yyyy-MM-dd HH:mm:ss
 * 模式的字母不能修改，但是连接符可以修改
 *      yyyy年MM月dd日 HH时mm分ss秒
 */
//格式化：
System.out.println(new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒").format(new Date()));
//解析：
System.out.println(new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒").parse("2019年12月26日 18时33分35秒"));

4.Calendar类：

/**
 * 4.Calendar类：日历类，java.util.Calendar，抽象类，提供操作日历的方法
 * 使用静态方法getInstance()返回Calendar类的子类对象
 * 常用的成员方法：
 *      public int get(int field)：返回给定日历字段的值
 *      public void set(int field,int value)：将给定日历字段设置为给定值
 *      public abstract void add(int field, int amount)：根据日历的规则，给日历字段添加或减去指定时间量
 *      public Date getTime()：返回一个表示此Calendar时间值的Date对象
 * 成员方法参数：
 *      int feild：日历类字段，可以使用Calendar类的静态成员变量获取
 *      YEAR = 1  年
 *      MONTH = 2 月
 *      DATE = 5  日
 *      DAY_OF_MONTH = 5 月中的某一天
 *      HOUR = 10       时
 *      MINUTE = 12     分
 *      SECOND = 13     秒
 */
Calendar c = Calendar.getInstance();

//返回当前年
System.out.println(c.get(Calendar.YEAR));

//设置当前年
c.set(Calendar.YEAR,9999);
System.out.println(c.get(Calendar.YEAR));

//增加年
c.add(Calendar.YEAR,3);
System.out.println(c.get(Calendar.YEAR));

//获取日期
System.out.println(c.getTime());

5.System类：

/**
 * 5.System类：获取与系统相关的信息或操作系统操作,java.lang.System
 *
 */
//返回以毫秒为单位的系统时间
System.out.println(System.currentTimeMillis());

//将数组指定的数据拷贝到另一个数组中
int[] src = {1,2,3,4,5};
int[] dest = {6,7,8,9,0};
System.arraycopy(src,0,dest,0,3);
System.out.println(Arrays.toString(dest));      //[1, 2, 3, 9, 0]

6.StringBuilder类：

/**
 * 6.StringBuilder类：字符串缓冲区，可变的字符串，初始值为16个字符
 * String类不可变字符串
 */
//空的构造函数
StringBuilder bu1 = new StringBuilder();
System.out.println(bu1);

//带参构造函数
StringBuilder bu2 = new StringBuilder("abc");
System.out.println(bu2);

//链式编程
bu2.append(1).append(true).append("你好");
System.out.println(bu2);

//StringBuilder->String
String bu2tos = bu2.toString();
System.out.println(bu2tos);

//String->StringBuilder
bu2.append(bu2tos);
System.out.println(bu2);

7.包装类：

/**
 * 7.包装类：8个，java.lang中
 * 由于基本类型好用但是没有对应的方法操作基本类型，
 * 我们定义一个类，将基本数据类型封装起来并在这个类中定义一些方法用于操作
 * 基本类型             包装类
 * byte                 Byte
 * short                Short
 * int                  Integer
 * long                 Long
 * float                Float
 * double               Double
 * char                 Character
 * boolean              Boolean
 *
 *
 * 从JDK1.5开始，支持自动装箱和自动拆箱
 * 装箱：基本类型->包装类
 * 拆箱：包装类->基本类型
 */
//int -> Integer
Integer i = Integer.valueOf(11111);
System.out.println(i);

//String -> Integer
i = Integer.valueOf("22222222");
System.out.println(i);

//Integer -> int
int num = i.intValue();
System.out.println(num);

//由于泛型必须是非基本类型
ArrayList<Integer> list = new ArrayList<>();

//自动装箱：list.add(new Integer(1))
list.add(1);
//自动拆箱：list.get(0).intValue();
int a = list.get(0);

//基本类型转字符串
String ss = 100 + "";
System.out.println(ss);
ss = Integer.toString(123);
System.out.println(ss);
ss = String.valueOf(444);
System.out.println(ss);

//字符串转基本类型
int nn = Integer.parseInt(ss);
System.out.println(nn);

 8.UUID类：

• 表示通用唯一标识符 (UUID) 的类。 UUID 表示一个 128 位的值。
• 作用：生成唯一的编号
• 常用方法：UUID.randomUUID() 用于生成唯一的编号

UUID u;
for (int i = 0; i < 100; i++) {
    u = UUID.randomUUID();
    System.out.println(u.toString().replaceAll("-",""));
}

9.Format类：

• Format类是一个用于格式化语言环境敏感的信息（如日期、消息和数字）的抽象基类。
• 拥有的子类：
  • DateFormat：为抽象日期类
    • SimpleDateFormat：是一个以与语言环境有关的方式来格式化和解析日期的具体类。
  • MessageFormat：提供了以与语言无关方式生成连接消息的方式。
  • NumberFormat：是所有数值格式的抽象基类。
    • ChoiceFormat：是一个允许将格式应用到某个范围的数。
    • DecimalFormat：用于格式化十进制数字。

（1）ChoiceFormat：

注：

• 两个数组长度必须相同，才能进行格式化。
• 当数字小于数组第一个数时，输出第一个数。当数字大于数组最后一个数时输出最后一个数。
• 输出规则 ：当且仅当 limit[j] <= X < limit[j+1] 时，X 匹配 j  （就是输出左侧数字）

double[] limits = {3, 4, 5, 6, 7, 8, 9};
String[] formats = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
ChoiceFormat format = new ChoiceFormat(limits, formats);
System.out.println(format.format(-100));    //星期一
System.out.println(format.format(3.6));     //星期一

（2）DecimalFormat：

• 使用‘0’和‘#’号表示数字，区别在于‘#’号会省略末尾多余的0

// 取整数部分
String s1 = new DecimalFormat("0").format(12345.1512134567);
System.out.println(s1);//12345

// 取小数点后1位,四舍五入
String s2 = new DecimalFormat("0.0").format(12345.1512134567);
System.out.println(s2);//12345.2

// 取小数点后3位，不足部分取0
String s3 = new DecimalFormat("0.000").format(12345.1);
System.out.println(s3);//12345.100

// 百分比
String s4 = new DecimalFormat("0.0%").format(12345.1512134567);
System.out.println(s4);// 1234515.1%

// 科学计数法
String s5 = new DecimalFormat("0.00E0").format(12345.1512134567);
System.out.println(s5);//1.23E4

// 每三位以逗号分开
String s6 = new DecimalFormat(",000.000").format(12345.1512134567);
System.out.println(s6);//12,345.151

//小数点后3位，如果是0则不显示
String s7 = new DecimalFormat("#.###").format(123.300);
System.out.println(s7);//123.3

//将格式嵌入文本
System.out.println(new DecimalFormat("每秒#.###米。").format(123.300));//每秒123.3米。

 9.Arrays类：

• Arrays是一个针对数组的工具类，可以进行复制，转换，排序，搜索，比较，填充等功能

（1）.复制

• copyOfRange(int[] original, int from, int to)：
  • 第一个参数表示源数组
  • 第二个参数表示开始位置(取得到)
  • 第三个参数表示结束位置(取不到)

public class ArraysTest {

    public static void main(String[] args) {
        int a[] = new int[]{18, 62, 68, 82, 65, 9};

        //1.Arrays复制
        int[] b = Arrays.copyOfRange(a, 0, 3);
        for (int i : b) {
            System.out.print(i + " ");
        }
        System.out.println();

        //2.System复制
        System.arraycopy(a, 0, b, 0, 3);
        for (int i : b) {
            System.out.print(i + " ");
        }
        
    }
}

（2）.转换为字符串

public class ArraysTest {

    public static void main(String[] args) {
        //1.返回一维数组的字符串形式
        int[] a = new int[]{18, 62, 68, 82, 65, 9};
        System.out.println(Arrays.toString(a));

        //2.返回多维数组的字符串形式
        int[][][] b = {{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, {{11, 12, 13}, {21, 22, 23}}};
        System.out.println(Arrays.deepToString(b));
        System.out.println(Arrays.toString(b));

        /**
         * 输出：
         * [18, 62, 68, 82, 65, 9]
         * [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[11, 12, 13], [21, 22, 23]]]
         * [[[I@135fbaa4, [[I@45ee12a7]
         */
    }
}

（3）.数组排序

public class ArraysSortTest {

    public static void main(String[] args) {
        //1.Arrays自带升序排序
        Integer[] nums1 = {5, 2, 1, 3, 4, 9, 0, 7, 8, 6};
        Arrays.sort(nums1);
        System.out.println(Arrays.toString(nums1));

        //2.自定义类
        Integer[] nums2 = {5, 2, 1, 3, 4, 9, 0, 7, 8, 6};
        Comparator<Integer> comparator = new MyComparator();
        Arrays.sort(nums2, comparator);
        System.out.println(Arrays.toString(nums2));

        //3.匿名内部类
        Integer[] nums3 = {5, 2, 1, 3, 4, 9, 0, 7, 8, 6};
        Arrays.sort(nums3, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return b - a;
            }
        });
        System.out.println(Arrays.toString(nums3));

        //4.lambda表达式
        Integer[] nums4 = {5, 2, 1, 3, 4, 9, 0, 7, 8, 6};
        Arrays.sort(nums4, (a, b) -> b - a);
        System.out.println(Arrays.toString(nums4));
    }
}


class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer a, Integer b) {
        return b - a;
    }
}

补充：

Comparable和Comparator区别比较：

• Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
• Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
• 两种方法各有优劣， 用Comparable 简单， 只要实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。 用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了

（4）.搜索

注意：搜索之前必须排序

public class ArraysTest {

    public static void main(String[] args) {
        int a[] = new int[]{18, 62, 68, 82, 65, 9};

        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //二分搜索之前必须排序
        System.out.println("数字62出现在数组中的位置"+Arrays.binarySearch(a,62));

        /**输出：
         * [9, 18, 62, 65, 68, 82]
         * 数字62出现在数组中的位置2
         */
    }
}

（5）.判断两个数组内容是否相同

public class ArraysTest {

    public static void main(String[] args) {
        int a[] = new int[]{18, 62, 68, 82, 65, 9};
        int b[] = new int[]{18, 62, 68, 82, 65, 9};
        int c[] = new int[]{99, 62, 68, 82, 65, 8};

        System.out.println(Arrays.equals(a,b));
        System.out.println(Arrays.equals(a,c));
        System.out.println(Arrays.equals(b,c));

        /**
         * 输出：
         * true
         * false
         * false
         */
    }
}

（6）.填充

public class ArraysTest {

    public static void main(String[] args) {
        int[] a = new int[10];

        //1.填充全部
        Arrays.fill(a, 5);

        System.out.println(Arrays.toString(a));

        /**
         * 输出：
         * [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
         */

        //2.填充下标[2,4]为1
        Arrays.fill(a, 2, 5, 1);
        System.out.println(Arrays.toString(a));

        /**
         * 输出：
         * [5, 5, 1, 1, 1, 5, 5, 5, 5, 5]
         */
    }
}