java几个类的简单使用

Random

Random类用来创建一个新的随机数生成器。

---

对象数组

ArrayList集合的长度是可以随意改变的。
ArrayList
这个 代表泛型
泛型：装在集合当中的所有元素，全部都是统一的类型。泛型只能是引用类型，不能使用基本元素。

import java.util.ArrayList;

public class ArrayListExercise {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("盖伦");
        list.add("锐雯");
        list.add("亚索");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

boolean add(E e)
E get(int index)
E remove(int index)
int size()

ArrayList集合中存储基本数据类型时，必须使用基本数据类型对应的包装类。

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

---

字符串

Java程序中的所有的字符串字面值（“ABC”）都作为此类的实例实现。

字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

---

字符串的构造方法和直接创建

public class StringExercise {
    public static void main(String[] args) {
        //使用空参构造
        String string1 = new String();
        System.out.println(string1);
        //使用字符数组构造
        char[] chars = {'A','B','C'};
        String string2 = new String(chars);
        System.out.println(string2);
        //使用字节数组构造
        byte[] bytes = {97,98,99};
        String string3 = new String(bytes);
        System.out.println(string3);
        //直接创建
        String string4 = "hello";
        System.out.println(string4);
    }
}

---

字符串常量池

程序当中直接写上的双引号字符串，就在字符串常量池中。

---

倒叙遍历

import java.util.Arrays;

public class ArraysExercise {
    public static void main(String[] args) {
        String string = "abdsdafawaswa";
        char[] chars = string.toCharArray();
        Arrays.sort(chars);
        //chars.fori快捷
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
        //chars.forr快捷
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }
}

---

改写Object类中的toString和equals方法

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    @Override
    public String toString() {
        //对toString方法进行重写，使可以输出自己想要输出的内容，而不再输出对应对象的地址
        return "Person{" + "name:" + name + ",age:" + age + "}";
    }
    /*
    Object类的equals方法，默认比较的是两个对象的地址值，没有意义
    可以进行重写，比较的内容自己设置
    问题：
        1、隐含一个多态
        2、多态的弊端：无法使用子类特有的内容（属性和方法）
        解决：可以使用向下转型把obj类型转换为自己定义的类型
     */
//    @Override
////    public boolean equals(Object obj) {
////        if(obj == this){
////            return true;
////        }
////        if(obj == null){
////            return false;
////        }
////        //向下转型
////        if(obj instanceof Person){
////            Person person = (Person)obj;
////            //比较两个对象的属性，一个为this，一个为转换的对象。
////            return this.name.equals(person.name) && this.age == person.age;
////        }
////        return false;//不是对应的类型，直接返回false
////    }

    @Override
    public boolean equals(Object o){
        if(this == o) return true;
        //getClass() != o.getClass()使用反射技术，判断o是否是Person类型，
        //等效于obj instanceof Person
        if(o == null || getClass() != o.getClass()) return false;
        Person person = (Person)o;
        return age == person.age && Objects.equals(name,person.name);
        //Objects.equals()方法会放在空指针异常（null）
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class ObjExercise {
    public static void main(String[] args) {
        Person person1 = new Person("sunwu",20);
        Person person2 = new Person("huayue",22);
        System.out.println(person1);
        System.out.println(person2);
        boolean bool = person1.equals(person2);
        System.out.println(bool);

    }
}

---

Data类

import java.util.Date;

public class DateExercise {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());
        demoOne();
        demoTwo();
        demeThree();
    }
    private static void demeThree() {
        Date data = new Date();
        System.out.println(data.getTime());
    }
    public static void demoOne(){
        Date date = new Date();
        System.out.println(date);
    }
    public static void demoTwo(){
        Date date = new Date(1583560500337L);
        System.out.println(date);
    }
}

---

DateFormat(抽象类）

格式化（日期-->文本）、解析（文本-->日期）

SimpleDateFormat类

构造方法：
SimpleDateFormat(String pattern)用给定的模式和默认环境的日期格式符号构造SimpleDateFormat

参数pattern：传递指定的模式
y年M月d日H时m分s秒
写对应的模式，会把模式替换为对应的日期和时间
"yyyy--MM-dd HH:mm:ss"，连接发符号可以改变

format(Date date)按照指定的模式，吧Date日期格式化为符号模式的字符串
parse(String source)把符号模式的字符串解析为date日期

parse声明了一个异常parseException，如果字符串和构造方法的模式不一样，那么程序就会抛出异常。这里采用不处理只声明异常的方法 throws ParseException

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

public class SimpleDateFormatExercise {
    public static void main(String[] args) throws ParseException {
        //demoOne();
        demoTwo();
    }

    private static void demoTwo() throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd  HH:mm:ss" );
        Date date = simpleDateFormat.parse("2020--03--07  23:07:52");
        System.out.println(date);
        //如果解析的字符串与格式不一样，就会抛出异常。
    }
    private static void demoOne(){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd  HH:mm:ss" );
        Date date = new Date();
        String dateFormat = simpleDateFormat.format(date);
        System.out.println(date);
        System.out.println(dateFormat);
    }
}

---

Calendar类：日历类（是一个抽象类），里面有很多操作日历字段的方法
Calendar类无法直接创建对象，里面有一个静态方法叫getInstance()，该方法返回了Calendarr类的子类对象。

常用的成员方法

1、 pubilc int get(int field)：返回给定日历字段的值
2、 pubilc void set(int field ,int value):将给定的日历字段设置为给定值
3、 public abstract void add(int field, int amout):根据日历的规则，为给定的日历字段添加或减去指定的时间量
4、 pubilc Date getTime():返回一个表示此Calendar时间值的Date对象

int field:日历类的字段，可以使用Calendar类的静态变量获取
YEAR = 1 年
MONTH = 2 月
DATE = 5 日
DAY_OF_MONTH = 5 月中的某一天
HOUR = 10 时
MINUTE = 12 分
SECOND = 13 秒

Calendar calendar = Calendar.getInstance();//多态(重点关注）

import java.util.Calendar;
import java.util.Date;

public class CalendarExercise {
    public static void main(String[] args) {
        //Calendar calendar = Calendar.getInstance();//多态
        //System.out.println(calendar);//从写toString方法
        //demoOne();
        //demoTwo();
        demoThree();
        //demoFour();
    }

    private static void demoFour() {
        Calendar calendar = Calendar.getInstance();
        Date date = calendar.getTime();
        System.out.println(date);
    }

    private static void demoThree() {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.YEAR,2);  // 正为加，负为减
        calendar.add(Calendar.MONTH,-3);
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH));

    }

    private static void demoTwo() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR,9999);  // 设置日期
        //calendar.set(888,88,88);
        System.out.println(calendar.get(Calendar.YEAR));
    }

    private static void demoOne() {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);
        int month = calendar.get(Calendar.MONTH);//西方是0-11
        System.out.println(month);
        int dateOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(dateOfMonth);
    }
}

---

System.CurrentTimeMillis()方法

public class CurrentTimeMillisExercise {
    public static void main(String[] args) {
        demoOne();
    }

    private static void demoOne() {
        long start = System.currentTimeMillis();  //获取毫秒值
        for (int i = 0; i <9999; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("\n程序运行时间：" + (end-start) + "毫秒");
    }
}

---

System.arraycopy(……)

System.arraycopy(object src,int srcPos,object dest,intdestPos,int length)：将数组中指定的数据拷贝到另一个数组

src：原数组
srcPos：原数组中的起始位置（索引）
dest：目标数组
destPos：目标数组中的起始位置
length：要复制的长度

import java.util.Arrays;

public class ArrayCopyExercise {
    public static void main(String[] args) {
        demo();
    }

    private static void demo() {
        int[] src = {1,2,3,4,5};
        int dest[] = {6,7,8,9,10};
        System.out.println("复制前：" + Arrays.toString(dest));
        System.arraycopy(src,0,dest,2,3); //从原数组(目标数组)要复制(被复制)的索引开始 + length  <=src.length()/dest.length()
        System.out.println("复制后：" + Arrays.toString(dest));
    }
}

---

Stingbuilder

字符串缓冲区支持可变的字符串。

public class StringBuilderExercise {
    public static void main(String[] args) {
        demoOne();
        demoTwo();
        demoThree();
        demoFour();
    }

    private static void demoFour() {
        String string = "hello";
        StringBuilder stringBuilder = new StringBuilder(string);
        stringBuilder.append("world");
        System.out.println(stringBuilder);
        final String string1 = stringBuilder.toString();
        System.out.println(string1);
    }

    private static void demoThree() {
        StringBuilder stringBuilderOne = new StringBuilder();
        stringBuilderOne.append("hello").append(123456789);  // 链式编程
        System.out.println(stringBuilderOne);
    }

    private static void demoTwo() {
        //带参构造
        StringBuilder stringBuilder = new StringBuilder("hello");
        System.out.println(stringBuilder);
    }

    private static void demoOne() {
        //空参构造方法
        StringBuilder stringBuilder = new StringBuilder();
        System.out.println(stringBuilder);
    }
}

---

装箱和拆箱

装箱：基本数据类型-->包装类
拆箱：包装类-->基本数据类型

可以使用构造方法或者使用valueOf方法进行装箱（对字符串类型的数和基本数据类型）。

可以进行自动装箱和自动拆箱

基本数据类型和字符串类型之间相互转换

1、基本数据类型的值 + "" （最简单）
2、包装类的静态方法toString(参数)， 和object是重载关系
3、String类的静态方法valueOf(参数)，将基本数据类型进行转换

1、使用包装类的静态方法parsexxx("数值类型的字符串")