第十三谈：常用类(2)

一、包装类：

/*
    java为了扩展每一个基本数据类型的功能，针对每一个基本数据类型都提供了一个对应的类，这些类统称为包装类
    byte: Byte
    short: Short
    int: Integer   
    long: Long
    float: Float
    double: Double
    boolean: Boolean
    char: Character  

    Integer类中的构造方法：
        public Integer(int value)
        public Integer(String s)


 */
public class BaoZhuangDemo1 {
    public static void main(String[] args) {
//        char c = '中';
//        int a = 10;
//        System.out.println(Integer.MAX_VALUE);
//        System.out.println(Integer.MIN_VALUE);

        //public Integer(int value) 将基本数据类型int包装成引用数据类型Integer
//        Integer i1 = new Integer(100);
//        System.out.println(i1); // 100
        Integer i1 = 100; // 自动装箱
        System.out.println(i1 + 1); // 自动拆箱

        //public Integer(String s)
//        Integer i2 = new Integer("nihao"); // NumberFormatException
//        System.out.println(i2);
        Integer i2 = new Integer("200");
        System.out.println(i2 + 3); // 自动拆箱

    }
}

二、Arrays类：

import java.util.Arrays;

/*
    Arrays: 该类中没有构造方法，但是有很多静态方法，这种类我们称之为工具类

    静态成员方法：
        public static String toString(int[] a)
        public static void sort(int[] a)
        public static int binarySearch(int[] a,int key)


 */
public class ArraysDemo1 {
    public static void main(String[] args) {
        //public static String toString(int[] a) 将数组以字符串的形式返回
        int[] arr = {12,32,33,16,27,31};
        String s1 = Arrays.toString(arr);
        System.out.println("排序前："+s1); // [11, 22, 33, 44, 55, 66]

        //public static void sort(int[] a) 快速排序，结果是升序的
        Arrays.sort(arr);
        System.out.println("排序后："+Arrays.toString(arr));

        //[12, 16, 27, 31, 32, 33]
        //public static int binarySearch(int[] a,int key) 二分查找 返回查找到元素的索引
        //前提：序列必须是有序的
        System.out.println(Arrays.binarySearch(arr, 100)); // -7

    }
}
/*
    public static int binarySearch(int[] a, int key) {
        // a -- [12, 16, 27, 31, 32, 33]
        // key -- 100
        // a.length -- 6
        return binarySearch0(a, 0, a.length, key); //
    }

    // Like public version, but without range checks.
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
        // a -- [12, 16, 27, 31, 32, 33]
        // fromIndex -- 0
        // toIndex -- 6
        // key -- 100
        int low = fromIndex; // 0
        int high = toIndex - 1; // 5

        while (low <= high) {
            int mid = (low + high) >>> 1; // 2  4  5
            int midVal = a[mid]; // 27  32  33

            if (midVal < key)
                low = mid + 1; // 3 5 6
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.  -7
    }


 */

三、Character类：

/*
    char - Character

    public static boolean isUpperCase(char ch)
    public static boolean isLowerCase(char ch)
    public static boolean isDigit(char ch)
    public static char toUpperCase(char ch)
    public static char toLowerCase(char ch)

 */
public class CharacterDemo1 {
    public static void main(String[] args) {
//        Character c1 = '中';
        boolean b1 = Character.isUpperCase('A');
        System.out.println(b1); // true

        boolean b2 = Character.isLowerCase('A');
        System.out.println(b2); // false

        //public static boolean isDigit(char ch) 判断一个字符是否是数字
        boolean b3 = Character.isDigit('中');
        System.out.println(b3); // true

        //public static char toUpperCase(char ch) 转大写
        char c1 = Character.toUpperCase('a');
        System.out.println(c1);

        //public static char toLowerCase(char ch) 转小写

    }
}

四、遍历集合：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
如何遍历一个集合：
    Object[] toArray()
    把集合转成数组，可以实现集合的遍历

    Iterator iterator()
    迭代器，集合的专用遍历方式

    学习集合的4步骤：
        1、创建集合对象
        2、创建元素对象
        3、向集合中添加元素
        4、遍历集合

 */
public class CollectionDemo4 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList(); // 接口多态
        //向集合中添加元素
        c1.add("java");
        c1.add("maven&git");
        c1.add("redis");
        c1.add("clickhouse");
        c1.add("hadoop");
//        c1.add(12);
        System.out.println("c1: " + c1);
        System.out.println("-----------------------");
        // Object[] toArray() 将集合转成数组，遍历数组，得到集合中每个元素
        Object[] array = c1.toArray();
        for (int i = 0; i < array.length; i++) {
            //Object obj = "java"
            //向下转型
            String s = (String) array[i]; // String s = "java"
            System.out.println(s + ", " + s.length());
        }
        System.out.println("===============================");
        //Iterator iterator() 迭代器遍历 是Collection集合特有遍历方式 可遍历的序列
        //获取迭代器对象，其中存储了集合元素
        //因为我这里的c1实际上堆内存是ArrayList的对象，所以调用iterator()底层返回的是一个ArrayList类中的私有成员内部类Itr的对象
        Iterator iterator = c1.iterator(); //Iterator iterator = new Itr()
        /*
            public Iterator<E> iterator() {
                return new Itr();
            }
         */

//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next()); // NoSuchElementException
        //我们应该在取下一个元素之前，先判断一下，下一个位置上有没有元素，如果有，就next()，否则就不获取
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        //虽然解决了不报错的问题，但是，但是要判断多少次也是不清楚的
        //在不知道次数的情况下，获取数据，优先使用while循环
        while (iterator.hasNext()) {
            String s = (String) iterator.next();
            System.out.println(s + ", " + s.length());
        }


    }
}

五、data类：

import java.util.Date;

/*
    Date类：和日期有关的类

    SimpleDateFormat类：和日期格式化有关的类

    构造方法：
        public Date()  将程序运行到此行时，此刻的时间
        public Date(long date)  将指定的时间戳转成对应的时间

 */
public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
//        System.out.println(date);
//        long time = date.getTime();
//        long l = System.currentTimeMillis();

        //public Date(long date)  将指定的时间戳转成对应的时间
        Date date1 = new Date(1709535166924L);
        System.out.println(date);
        // yyyy年MM月dd日 HH时mm分ss秒
    }
}

六、Integer类：

/*
    Integer类中的成员方法：
        int类型和String类型的相互转换（字符串中的内容要是数值内容）
            int – String
            String – int

        public int intValue()
        public static int parseInt(String s)
        public static String toString(int i)
        public static Integer valueOf(int i)
        public static Integer valueOf(String s)

 */
public class IntegerDemo1 {
    public static void main(String[] args) {
//        Integer i1 = 200; // 自动装箱
//        int i = i1.intValue(); // 手动获取被包装的数值
//        System.out.println(i);

        //public static int parseInt(String s)  将字符串转成数字
        //String->int
        int i = Integer.parseInt("100");
        System.out.println(i);

        //public static String toString(int i)
        //int->String
        String s1 = Integer.toString(200);
        System.out.println(s1); // "200"

        //public static Integer valueOf(int i)
        //int->Integer
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

        //public static Integer valueOf(String s)
        //String->Integer
        Integer i2 = Integer.valueOf("300");
        System.out.println(i2);


        //Integer->int
        Integer i3 = 400;
        int i4 = i3.intValue();
        System.out.println(i4);
        // 进制转换
        //public static String toBinaryString(int i)
        //public static String toOctalString(int i)
        //public static String toHexString(int i)

        String s = Integer.toBinaryString(20);
        System.out.println(s); // 10100


    }
}

七、Random类：

import java.util.Random;

/*
    Math.random() [0.0,1.0)



 */
public class RandomDemo1 {
    public static void main(String[] args) {
        Random random = new Random();
//        int i = random.nextInt();
//        System.out.println(i);

        //public int nextInt(int bound)  随机产生一个整数，范围在 [0,bound)
        System.out.println(random.nextInt(100)+1);


    }
}

八、SimpleDataFormat(日期格式化)类：

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

/*
    日期格式化类：SimpleDateFormat

    构造方法：
        public SimpleDateFormat(String pattern) yyyy年MM月dd日 HH时mm分ss秒

 */
public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");

        Date date = new Date();
        System.out.println(date); // Mon Mar 04 15:06:31 CST 2024

        String res1 = sdf.format(date); // 将Date类型的值格式化我们目标的形式
        System.out.println(res1);

        //需求：将一个时间戳转成指定日期格式 1709535166924
        //时间戳--Date--格式化
//        Date date1 = new Date(1709535166924L);
//        String res2 = sdf.format(date1);
//        System.out.println(res2);
        System.out.println(DateUtil.formatDate(1709535166924L));

    }
}

 九、String和StringBuffer的相互转换

/*
    String和StringBuffer的相互转换

    A<-->B
    什么场景需要做转换操作：
    场景1：可以需要用到另一种类中的方法，来方便处理我们的需求
    场景2：方法传参

 */
public class StringBufferDemo1 {
    public static void main(String[] args) {
        //创建一个String对象
        String s1 = "hello";
        System.out.println("s1: " + s1);

        //String-->StringBuffer
        //1、使用StringBuffer构造方法
        StringBuffer sb1 = new StringBuffer(s1);
        System.out.println("sb1: " + sb1);


        //StringBuffer-->String
        //1、toString()方法
        StringBuffer sb2 = new StringBuffer("world");
        String s2 = sb2.toString();
        //2、截取
        String s3 = sb2.substring(0);

        System.out.println("--------------转换调用另一种类中的方法案例-------------------");
        //String对象字符串逆序
        String s4 = "abcd";
        System.out.println("s4: "+s4);
        //先转StringBuffer
        StringBuffer sb3 = new StringBuffer(s4);
        sb3.reverse();
        //再转回字符串String类型
        String s5 = sb3.toString();
        System.out.println("s5: "+s5);


    }
}

十、System类：

/*
    System类：和系统操作相关的工具类

    public static void gc()
    public static void exit(int status)  强制退出程序
    public static long currentTimeMillis()  重要！！！



 */
public class SystemDemo1 {
    public static void main(String[] args) {
//        for (int i = 0; i < 10; i++) {
//            if(i==5){
                break;
//                System.exit(0);
//            }
//            System.out.println(i);
//        }
//
//        System.out.println("hello world");

        //public static long currentTimeMillis() 获取当前此刻的时间戳
        long l = System.currentTimeMillis();
        System.out.println(l);

    }
}