java几个类的简单使用

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

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

1import java.util.ArrayList;
2
3public class ArrayListExercise {
4    public static void main(String[] args) {
5        ArrayList<String> list = new ArrayList<>();
6        list.add("盖伦");
7        list.add("锐雯");
8        list.add("亚索");
9        for (int i = 0; i < list.size(); i++) {
10            System.out.println(list.get(i));
11        }
12    }
13}
14

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[]字节数组。

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

1public class StringExercise {
2    public static void main(String[] args) {
3        //使用空参构造
4        String string1 = new String();
5        System.out.println(string1);
6        //使用字符数组构造
7        char[] chars = {'A','B','C'};
8        String string2 = new String(chars);
9        System.out.println(string2);
10        //使用字节数组构造
11        byte[] bytes = {97,98,99};
12        String string3 = new String(bytes);
13        System.out.println(string3);
14        //直接创建
15        String string4 = "hello";
16        System.out.println(string4);
17    }
18}

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

###倒叙遍历

1import java.util.Arrays;
2
3public class ArraysExercise {
4    public static void main(String[] args) {
5        String string = "abdsdafawaswa";
6        char[] chars = string.toCharArray();
7        Arrays.sort(chars);
8        //chars.fori快捷
9        for (int i = 0; i < chars.length; i++) {
10            System.out.println(chars[i]);
11        }
12        //chars.forr快捷
13        for (int i = chars.length - 1; i >= 0; i--) {
14            System.out.println(chars[i]);
15        }
16    }
17}

##改写Object类中的toString和equals方法

1import java.util.Objects;
2
3public class Person {
4    private String name;
5    private int age;
6
7    @Override
8    public String toString() {
9        //对toString方法进行重写，使可以输出自己想要输出的内容，而不再输出对应对象的地址
10        return "Person{" + "name:" + name + ",age:" + age + "}";
11    }
12    /*
13    Object类的equals方法，默认比较的是两个对象的地址值，没有意义
14    可以进行重写，比较的内容自己设置
15    问题：
16        1、隐含一个多态
17        2、多态的弊端：无法使用子类特有的内容（属性和方法）
18        解决：可以使用向下转型把obj类型转换为自己定义的类型
19     */
20//    @Override
21////    public boolean equals(Object obj) {
22////        if(obj == this){
23////            return true;
24////        }
25////        if(obj == null){
26////            return false;
27////        }
28////        //向下转型
29////        if(obj instanceof Person){
30////            Person person = (Person)obj;
31////            //比较两个对象的属性，一个为this，一个为转换的对象。
32////            return this.name.equals(person.name) && this.age == person.age;
33////        }
34////        return false;//不是对应的类型，直接返回false
35////    }
36
37    @Override
38    public boolean equals(Object o){
39        if(this == o) return true;
40        //getClass() != o.getClass()使用反射技术，判断o是否是Person类型，
41        //等效于obj instanceof Person
42        if(o == null || getClass() != o.getClass()) return false;
43        Person person = (Person)o;
44        return age == person.age && Objects.equals(name,person.name);
45        //Objects.equals()方法会放在空指针异常（null）
46    }
47
48    public Person(String name, int age) {
49        this.name = name;
50        this.age = age;
51    }
52
53    public String getName() {
54        return name;
55    }
56
57    public void setName(String name) {
58        this.name = name;
59    }
60
61    public int getAge() {
62        return age;
63    }
64
65    public void setAge(int age) {
66        this.age = age;
67    }
68}
69
70
71public class ObjExercise {
72    public static void main(String[] args) {
73        Person person1 = new Person("sunwu",20);
74        Person person2 = new Person("huayue",22);
75        System.out.println(person1);
76        System.out.println(person2);
77        boolean bool = person1.equals(person2);
78        System.out.println(bool);
79
80    }
81}

##Data类

1import java.util.Date;
2
3public class DateExercise {
4    public static void main(String[] args) {
5        System.out.println(System.currentTimeMillis());
6        demoOne();
7        demoTwo();
8        demeThree();
9    }
10    private static void demeThree() {
11        Date data = new Date();
12        System.out.println(data.getTime());
13    }
14    public static void demoOne(){
15        Date date = new Date();
16        System.out.println(date);
17    }
18    public static void demoTwo(){
19        Date date = new Date(1583560500337L);
20        System.out.println(date);
21    }
22}

##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

1import java.text.ParseException;
2import java.text.SimpleDateFormat;
3import java.util.Date;
4
5public class SimpleDateFormatExercise {
6    public static void main(String[] args) throws ParseException {
7        //demoOne();
8        demoTwo();
9    }
10
11    private static void demoTwo() throws ParseException {
12        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd  HH:mm:ss" );
13        Date date = simpleDateFormat.parse("2020--03--07  23:07:52");
14        System.out.println(date);
15        //如果解析的字符串与格式不一样，就会抛出异常。
16    }
17    private static void demoOne(){
18        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd  HH:mm:ss" );
19        Date date = new Date();
20        String dateFormat = simpleDateFormat.format(date);
21        System.out.println(date);
22        System.out.println(dateFormat);
23    }
24}

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();//多态(重点关注）

1import java.util.Calendar;
2import java.util.Date;
3
4public class CalendarExercise {
5    public static void main(String[] args) {
6        //Calendar calendar = Calendar.getInstance();//多态
7        //System.out.println(calendar);//从写toString方法
8        //demoOne();
9        //demoTwo();
10        demoThree();
11        //demoFour();
12    }
13
14    private static void demoFour() {
15        Calendar calendar = Calendar.getInstance();
16        Date date = calendar.getTime();
17        System.out.println(date);
18    }
19
20    private static void demoThree() {
21        Calendar calendar = Calendar.getInstance();
22        calendar.add(Calendar.YEAR,2);  // 正为加，负为减
23        calendar.add(Calendar.MONTH,-3);
24        System.out.println(calendar.get(Calendar.YEAR));
25        System.out.println(calendar.get(Calendar.MONTH));
26
27    }
28
29    private static void demoTwo() {
30        Calendar calendar = Calendar.getInstance();
31        calendar.set(Calendar.YEAR,9999);  // 设置日期
32        //calendar.set(888,88,88);
33        System.out.println(calendar.get(Calendar.YEAR));
34    }
35
36    private static void demoOne() {
37        Calendar calendar = Calendar.getInstance();
38        int year = calendar.get(Calendar.YEAR);
39        System.out.println(year);
40        int month = calendar.get(Calendar.MONTH);//西方是0-11
41        System.out.println(month);
42        int dateOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
43        System.out.println(dateOfMonth);
44    }
45}

####System.CurrentTimeMillis()方法

1public class CurrentTimeMillisExercise {
2    public static void main(String[] args) {
3        demoOne();
4    }
5
6    private static void demoOne() {
7        long start = System.currentTimeMillis();  //获取毫秒值
8        for (int i = 0; i <9999; i++) {
9            System.out.println(i);
10        }
11        long end = System.currentTimeMillis();
12        System.out.println("\n程序运行时间：" + (end-start) + "毫秒");
13    }
14}

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

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

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

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

1public class StringBuilderExercise {
2    public static void main(String[] args) {
3        demoOne();
4        demoTwo();
5        demoThree();
6        demoFour();
7    }
8
9    private static void demoFour() {
10        String string = "hello";
11        StringBuilder stringBuilder = new StringBuilder(string);
12        stringBuilder.append("world");
13        System.out.println(stringBuilder);
14        final String string1 = stringBuilder.toString();
15        System.out.println(string1);
16    }
17
18    private static void demoThree() {
19        StringBuilder stringBuilderOne = new StringBuilder();
20        stringBuilderOne.append("hello").append(123456789);  // 链式编程
21        System.out.println(stringBuilderOne);
22    }
23
24    private static void demoTwo() {
25        //带参构造
26        StringBuilder stringBuilder = new StringBuilder("hello");
27        System.out.println(stringBuilder);
28    }
29
30    private static void demoOne() {
31        //空参构造方法
32        StringBuilder stringBuilder = new StringBuilder();
33        System.out.println(stringBuilder);
34    }
35}

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

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

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

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

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

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

java几个类的简单使用

评论区

相关推荐