Java高级程序笔记（1）

最新推荐文章于 2024-04-19 16:14:14 发布

玖霆

最新推荐文章于 2024-04-19 16:14:14 发布

阅读量147

点赞数 1

分类专栏： Java后台笔记文章标签： java 笔记开发语言

本文链接：https://blog.csdn.net/m0_73895936/article/details/132466794

版权

Java后台笔记专栏收录该内容

6 篇文章 1 订阅

订阅专栏

Java核心api

1.1集合的概述

集合类的特点：提供一种存储空间可变的存储模型。存储的容量可以发生改变

1.2集合类型结构

Java集合框架提供了一套性能优良、使用方便的接口和类，他们位于java.util包中。

Collection（单列：接口）“下标”

List(可重复：接口)：ArrayList(具体类)、LinkedList（具体类）。

Set（不可重复接口：接口）：HashSet（具体类）、TreeSet(具体类)

Map（双列：接口）“键值对”

HashMap（具体类）

TreeMap（具体类）

package com.kg.test;

import java.util.ArrayList;
import java.util.Scanner;

public class Test01 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList<>();
        //通过add方法向集合中添加元素
        list.add(100);
        list.add(200);
        list.add("hello");
        list.add("word");
        list.add("张三");
        //通过get方法根据下标获得指定的元素
        System.out.println(list.get(2));
        //通过size方法返回集合的长度
        System.out.println("集合的长度为："+list.size());

        while (true){
            System.out.println("请输入添加的内容：");
            Scanner input = new Scanner(System.in);
            String s =input.next();
            //contains方法用于判断集合中是否存在指定的元素
            if (!list.contains(s)) {
                list.add(s);
                System.out.println("添加成功！");
            }else {
                System.out.println("该内容已存在");
            }
            list.add(s);
            System.out.println("是否继续添加（y/n）");
            String isgo= input.next();
            if (!"y".equals(isgo)){
                break;
            }
        }
    }
}

package com.kg.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Scanner;

public class Test01 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Collection list=new ArrayList<>();
        //通过add方法向集合中添加元素
        list.add(100);
        list.add(200);
        list.add("hello");
        list.add("word");
        list.add("张三");
        //通过get方法根据下标获得指定的元素
//        System.out.println(list.get(2));
        //用于移除集合中指定的元素
        list.remove(200);
        System.out.println("是否清空集合？y/n");
        String isclaer = input.next();
        if (isclaer.equals("y")) {
            //clear方法用于清空集合
            list.clear();
        }
        //通过size方法返回集合的长度
        System.out.println("集合的长度为："+list.size());

        while (true){
            System.out.println("请输入添加的内容：");

            String s =input.next();
            //contains方法用于判断集合中是否存在指定的元素
            if (!list.contains(s)) {
                list.add(s);
                System.out.println("添加成功！");
            }else {
                System.out.println("该内容已存在");
            }
            list.add(s);
            System.out.println("是否继续添加（y/n）");
            String isgo= input.next();
            if (!"y".equals(isgo)){
                break;
            }
        }
    }
}

1.3迭代器

Iterator：迭代器，集合的专用遍历方式

Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
迭代器是通过iterator()方法得到的，所以我们说它是依赖于集合而存在的

package com.kg.test;


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

public class Test02 {
    public static void main(String[] args) {
        ArrayList list =new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add("hello");
        list.add("word");
        list.add("张三");
        /**
         * 使用集合的迭代器遍历集合
         * 通过集合对象的iterator方法返回一个迭代器对象
         * 迭代器对象有两个方法：
         * next方法，用于获取集合中的下一个元素
         * hasNext方法，用于返回有没有下一个元素
         */
        Iterator it = list.iterator();
        System.out.println(it.hasNext());
        System.out.println(it.next());
        System.out.println(it.next());
    }
}

1.4 List集合概述和特点

List集合概述

有序集合（也称序列），用户可以精确控制列表中每个元素插入位置，用户可以通过整数索引访问元素，并搜索列表的元素。与set集合不同，列表通常允许重复的元素

package com.kg.test;

import java.util.ArrayList;
import java.util.List;

public class Test03 {
    public static void main(String[] args) {
        /**
         * 创建一个list集合，list是collection的子接口，collection的所有方法它都有
         * list提供根据索引操作集合元素的方法
         */
        List list =new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(2,40);
        //list集合可以根据下标添加元素
        System.out.println(list);
        //set方法根据下标修改指定位置的元素
        list.set(1,"zrb");
        System.out.println(list);
        //list集合对collection的remove方法进行了重写，提供了根据下标溢出指定元素的功能
        list.remove(2);
        System.out.println(list);
    }
}

1.4.1遍历集合

package com.kg.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

public class Test03 {
    public static void main(String[] args) {
        /**
         * 创建一个list集合，list是collection的子接口，collection的所有方法它都有
         * list提供根据索引操作集合元素的方法
         */
        List list =new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(2,40);
        //list集合可以根据下标添加元素
        System.out.println(list);
        //set方法根据下标修改指定位置的元素
        list.set(1,"zrb");
        System.out.println(list);
        //list集合对collection的remove方法进行了重写，提供了根据下标溢出指定元素的功能
        list.remove(2);
        System.out.println(list);
        System.out.println("-------------------1.迭代器遍历集合-------------------------------");
        //利用迭代器遍历集合
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("------------------2.for循环遍历集合-----------------------------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("------------------3.增强for循环遍历集合-------------------------");
        /**
         * 注意：增强for是最新的遍历集合的语法
         * 方式：for（遍历对象:集合）
         */
        for(Object o :list){
            System.out.println(o);
        }
    }
}

1.5 List集合子类特点

ArrayList：底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删快

数组结构

查询数据通过索引定位，查询任意数据耗时相同，查询速度快; 删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低; 添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低;

链表结构

节点和节点的连接，节点：保存数据和下一个节点的地址; 链表是一种增删快的模型（对比数组），只需要修改其中某个节点中地址的指向; 链表是一个查询慢的模型（对比数组），需要从头开始查;

package com.kg.test;

import java.util.Iterator;
import java.util.LinkedList;

public class Test06 {
    public static void main(String[] args) {
        LinkedList<String> list =new LinkedList<String>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        //根据指定位置添加元素
        list.add(2,"cc");
        //addFirst方法表示在集合的开头添加元素
        list.addFirst("滚蛋");
        //addLast方法表示在集合的末尾添加元素
        list.addLast("滚蛋喽");
        System.out.println(list);
        System.out.println(list.get(2));
        System.out.println(list.getFirst());//获取了第一个元素
        System.out.println(list.getLast());//获取了最后一个元素
        list.remove(list.get(3));
        System.out.println(list.removeFirst());//移除了第一个元素
        System.out.println(list.removeLast());//移除了最后一个元素
        System.out.println(list);
        System.out.println("*******************1.迭代器***********************");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("*******************2.for循环***********************");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("*******************3.增强for循环********************");
        for(String s: list){
            System.out.println(s);
        }
        list.clear();
        System.out.println("集合的长度是："+list.size());
    }
}

1.6 HashSet集合的概述和特点

HashSet 集合特点：

底层数据结构是哈希表
对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以是不包含重复元素的集合

package com.kg.test;

import java.util.HashSet;
import java.util.Set;

public class Test07 {
    public static void main(String[] args) {
        /**
         * 创建一个HashSet集合对象
         * set集合的特点：1.不能添加重复数据。 2.没有索引。  3.内部会对集合进行排序
         */
        Set<String> sets =new HashSet<String>();
        sets.add("7");
        sets.add("4");
        sets.add("5");
        sets.add("2");
        sets.add("1");
        System.out.println(sets);
    }
}

1.7 TreeSet集合的概述和特点

TreeSet集合特点：

元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet()：根据其元素的自然排序进行排序
TreeSet(Comparator comparator)：根据指定的比较器进行排序

没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以不包含重复元素的集合

创建Stu类

package com.kg.test;

import java.util.Comparator;

public class Stu implements Comparable<Stu> {
    private String name;
    private int age;

    public Stu() {
    }
    public Stu(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;
    }
//重写compareTo方法，实现自定义排序规则
    @Override
    public int compareTo(Stu o) {
        int m =this.getAge()-o.getAge();
        return m;
    }
    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
    public boolean equals(Stu obj) {
        if (this.getName().equals(obj.getName()) && this.getAge() == obj.getAge()) {
            return true;
        }else {
            return false;
        }
    }
}

创建Teacher类

package com.kg.test;

public class Teacher {
    private String name;
    private int age;
    public Teacher() {
    }
    public Teacher(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;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

创建测试类Test

package com.kg.test;

import java.util.Comparator;
import java.util.HashSet;
import java.util.TreeSet;

public class Test08 {
    public static void main(String[] args) {
        //TreeSet 和 HashSet都是Set接口的实现类
        //在创建TreeSet集合时，如果构造函数没有传参，那么它只能对实现了Comparable的类型排序
        TreeSet<Integer> set1 = new TreeSet<Integer>();
        set1.add(6);
        set1.add(3);
        set1.add(2);
        set1.add(5);
        System.out.println(set1);
        System.out.println("-----------------------------------------------");
        TreeSet<Stu> set2 = new TreeSet<Stu>();
        Stu s1= new Stu("张三",12);
        Stu s2= new Stu("张二",42);
        Stu s3= new Stu("张四",32);
        Stu s4= new Stu("张一",62);
        set2.add(s1);
        set2.add(s2);
        set2.add(s3);
        set2.add(s4);
        for (Stu s :set2){
            System.out.println(s);
        }
        System.out.println("-----------------------------------------------");
        //如果集合的类型没有实现comparable接口，也可以在treeset构造函数中传入一个比较器实现排序规则
        TreeSet<Teacher> set3 = new TreeSet<Teacher>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher t1, Teacher t2) {
                int m = t1.getAge()-t2.getAge();
                return m==0?t1.getName().compareTo(t2.getName()):m;
            }
        });
        Teacher t1 = new Teacher("张三",12);
        Teacher t2 = new Teacher("张四",22);
        Teacher t3 = new Teacher("张五",15);
        Teacher t4 = new Teacher("张六",13);
        set3.add(t1);
        set3.add(t2);
        set3.add(t3);
        set3.add(t4);
        for (Teacher t: set3){
            System.out.println(t);
        }
        System.out.println("-----------------------------------");
        Stu stu1 = new Stu("张三",12);
        Stu stu2 = new Stu("张三",12);
        System.out.println(stu2.equals(stu1));//重写equals方法实现两元素的比较
    }
}

**Set集合特点:**不包含重复元素的集合没有带索引的方法，所以不能使用普通for循环遍历

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

public int hashCode()：返回对象的哈希码值

对象的哈希值特点：

同一个对象多次调用hashCode()方法，返回的哈希值是相同的
默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

1.8泛型

泛型定义格式：

<类型>：指定一种类型的格式。这里的类型可以看成是形参。
<类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参。
将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型。

创建管理类Manager

package com.kg.test;

public class Manager<T> {
    public T[] datas ;
    public void addDate(T data){
        for (int i = 0; i < datas.length; i++) {
            if (datas[i] == null) {
                datas[i] = data;
                break;
            }
        }
    }
    public void showData(){
        for (int i = 0; i < datas.length; i++) {
            if (datas[i]!= null) {
                System.out.println(datas[i]);
            }
        }
    }
}
//汽车类
 class Car{
    private String number;
    private String name;

    public Car() {
    }

    public Car(String number, String name) {
        this.number = number;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Car{" +
                "number='" + number + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}
 //手机类
 class Phone{
    private String name;
    private String color;

     public Phone() {
     }

     public Phone(String name, String color) {
         this.name = name;
         this.color = color;
     }

     @Override
     public String toString() {
         return "Phone{" +
                 "name='" + name + '\'' +
                 ", color='" + color + '\'' +
                 '}';
     }
 }

创建测试类 Test01

package com.kg.test;

public class Test01 {
    public static void main(String[] args) {
        Manager<Car> m =new Manager<Car>();
        m.datas=new Car[10];
        Car c1 = new Car("豫N250250","大众-探岳");
        Car c2 = new Car("豫ND282B","本田CR-V");
        m.addDate(c1);
        m.addDate(c2);
        m.showData();
        System.out.println("-------------------------------------------");
        Manager<Phone> m2 = new Manager<Phone>();
        m2.datas = new Phone[10];
        Phone p1 = new Phone("华为","黑色");
        Phone p2 = new Phone("荣耀","银白色");
        m2.addDate(p1);
        m2.addDate(p2);
        m2.showData();
    }
}

1.8.1泛型通配符

package com.kg.test;

import java.util.ArrayList;
import java.util.List;

public class Test02 {
    public static void main(String[] args) {
        //先定义集合
        List<?> list;
        /*
        再在程序的某个地方初始化集合，问题是，有时候我们要在初始化的时候才知道类型
        这种情况下可以使用泛型通配符？他的元素可以匹配任何类型。
         */
        list = new ArrayList<String>();
        //指定泛型的上限类型，在初始化集合时不能超过上限类型
        List<? extends Mammal> list2 = new ArrayList<Person>();
        //指定泛型的下限类型，在初始化集合时不能小于下限类型
        List<? super Mammal> list3 = new ArrayList<Mammal>();
    }
}
class Animal{
    public void eat(){
        System.out.println("动物要吃饭");
    }
}
class Mammal extends Animal{
    public void sleep(){
        System.out.println("哺乳动物需要大量的睡眠");
    }
}
class Person extends Mammal{
    public void play(){
        System.out.println("人喜欢玩");
    }
        }

1.9 Map集合的概述和特点

Map集合概述

Interface Map<k,v> k：键的类型；v：值的类型
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
举例：学生的学号和姓名（s1001=>周杰伦）

package com.kg.test;

import java.util.HashMap;
import java.util.Map;

public class Test03 {
    public static void main(String[] args) {
        /*
         *Map表示键值对集合,Map表示接口，HashMap表示具体的实现类
         * 这里我们指定了集合的键是String类型，集合的值为int类型
         */
        Map<String,Integer> map=new HashMap<String,Integer>();
        //往集合中添加元素，在存储数据时，他的内部会根据键值的哈希值来进行排序
        map.put("a",100);
        map.put("b",200);
        map.put("c",300);
        //注意：键值不允许重复的，如果重复添加，后添加的会将之前的替换
        map.put("c",600);
        //所以通常在添加元素时，要先判断key是否重复
        if(!map.containsKey("d")){
            map.put("d",400);
        }
        //map集合还可以判断是否存储了指定的值
        System.out.println("集合中是否储存了200"+map.containsValue(200)+"\t");
        //根据键获取值，没有键则返回null值
        System.out.println(map.get("a"));
        //根据键移除值
        map.remove("b");
        System.out.println(map);
        //清空集合
        map.clear();
        //判断集合是否为空
        System.out.println("集合是否为空："+map.isEmpty()+"\t");
    }
}

1.9.1遍历map集合的方法

package com.kg.test;

import com.sun.jdi.Value;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test04 {
    public static void main(String[] args) {
        Map<String,Double> map =new HashMap<String,Double>();
        map.put("张三",2000.1);
        map.put("李四",230.2);
        map.put("王五",204.6);
        map.put("赵六",504.3);
        //keyset方法返回所有的键集合，返回类型是一个set集合
        Set<String> sets=map.keySet();
        System.out.println(sets);
        System.out.println("******************1.增强for循环************************");
        //可以遍历所有的键
        for (String key:sets){
            //再根据键获取值
            System.out.println(key+":"+map.get(key));
        }
        System.out.println("******************2.values方法************************");
        Collection<Double> values =map.values();
        for (Double value: values){
            System.out.println(value);
        }
        System.out.println("******************3.entrySet()方法************************");
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        //entrySet()方法返回的是键值对对象集合
        for (Map.Entry<String, Double> kv:entries){
            /*
            键值对对象的getKey方法返回key
            键值对对象的getvalue方法返回value
             */
            System.out.println(kv.getKey()+":"+kv.getValue());
        }

    }
}

1.10 Collections排序所用的方法

package com.kg.test;

import java.util.*;

/**
 * @author:zrb
 * @description:
 * @date:
 */
public class Test06 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(333);
        list.add(555);
        list.add(222);
        list.add(444);
        list.add(111);
        /*
        sort方法，对list集合进行升序排列，Collection.sort(list);
        reverse方法，对List集合进行翻转， Collections.reverse(list);
        shuffle方法：对集合进行随机打乱，Collections.shuffle(list);
         */
        Collections.sort(list);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

1.11枚举类型

枚举指由一组固定的常量组成的类型：类型安全、易于输入、代码清晰

创建枚举类(1)Gender：

package com.kg.test;

/**
 * @author ZRB
 * @description:性别枚举
 * @date 2023/8/22 14:10
 */
//class定义类、interface定义接口、enum定义枚举
public enum Gender {
   男, 女
}

创建枚举类（2）Grade：

package com.kg.test;
/**
 *@author ZRB
 *@description :年级枚举
 *@date 2023/8/22 14:13
 */
public enum Grade {
    一年级, 二年级, 三年级
}

创建属性Stu

package com.kg.test;

/**
 * @author ZRB
 * @description
 * @date 2023/8/22 14:18
 */
public class Stu {
    private String name;
    private String age;
    private  Gender sex;
    private Grade grade;

    public Stu() {
    }

    public Stu(String name, String age, Gender sex, Grade grade) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

    public Gender getSex() {
        return sex;
    }

    public void setSex(Gender sex) {
        this.sex = sex;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", sex=" + sex +
                ", grade=" + grade +
                '}';
    }
}

创建测试类Test

package com.kg.test;

/**
 * @author:zrb
 * @description:枚举
 * @date:2023/8/22 14:02
 */
public class Test07 {
    public static void main(String[] args) {
        Stu s = new Stu();
        s.setName("张三");
        s.setGrade(Grade.一年级);
        s.setSex(Gender.男);
        System.out.println(s);
    }
}

1.12包装类

基本类型包装类概述：将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

**常用的操作之一：**用于基本数据类型与字符串之间的转换

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

package com.kg.test;

/**
 * @author ZRB
 * @description :包装类
 * @date 2023/8/22 14:27
 */
public class Test08 {
    public static void main(String[] args) {
        /**
         * 包装类：将基本数据类型封装成对象，注意：在使用泛型集合是，基本类型必须要指定包装类型1
         * 通过构造函数创建包装对象（过时）
         * Integer i =new Integer(100);
         * 通过valueof方法返回包装对象（最新）
         */
        Integer i =Integer.valueOf(100);
        //tostring方法、转字符串
        String s = i.toString();
        System.out.println(s);
    }
}

1.13装箱和拆箱

自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类类型
拆箱：把包装类类型转换为对应的基本数据类型

package com.kg.test;

/**
 * @author ZRB
 * @description :装箱与拆箱
 * @date 2023/8/22 15:53
 */
public class Test11 {
    public static void main(String[] args) {
        int i = 100;
        Integer i1 = i; //自动将int装箱为Integer
        int i2 = i1;//自动将integer拆箱为int
        //注意：int定义变量不能赋值为null
        //int i3 = null;会报错
        Integer i4 = null;
        //如若将null值的Integer进行拆箱，在运行时会引发:NullPointerException
        int i5=i4;
        System.out.println(i5);
    }
}

1.14字符串类型转换为整型

package com.kg.test;

/**
 * @author ZRB
 * @description :包装类
 * @date 2023/8/22 14:45
 */
public class Test09 {
    public static void main(String[] args) {
        String str = "你好-世界-hello-word";
        //字符串的split方法，用于将一个字符串根据某个字符串打散成字符串数组String[ ] arrs = str.split( regex: "-");
        String [] arrs = str.split("-");
        for (String s1 : arrs){
            System.out.println(s1);
        }
        System.out.println("----------------1.字符串数组转换为int类型数组--------------------");
        String [] arr2 = {"100","100","100","100","100"};
        int[] num2 = new  int[arr2.length];
        for (int i = 0; i < arr2.length; i++) {
            //通过Integer.paeseIntXXX方法，用于将字符串类型转换为值类型。
            num2[i]= Integer.parseInt(arr2[i]);
            System.out.println(num2[i]);
        }
    }
}

1.14.1 StringBuilder字符串和StringBuffer字符串

package com.kg.test;

/**
 * @author ZRB
 * @description :StringBuilder字符串
 * @date 2023/8/22 15:02
 */
public class Test10 {
    public static void main(String[] args) {
        /**
         * StringBuilder和StringBuffer 都是用于定义强类型字符串
         * 定义String的方式有：
         * 1.直接定义
         */
        String s1="hello";//直接定义第一个字符串时jvm会帮你在堆中创建一个空间存储数据
        String s2="hello";//直接定义第二个字符串时，如果内容在之前出现过，jvm很聪明，直接把直接创建的字符串地址赋给此处
        String s3 = new String("worder");
        String s4 = new String("worder");
        //判断两字符串的地址是否相同
        System.out.println(s1.equals(s2));
        //判断两字符串的内容是否相同
        System.out.println(s1==s2);
        //判断两字符串的内容是否相同
        System.out.println(s3.equals(s4));
        //判断两字符串的地址是否相同
        System.out.println(s3==s4);
        //注意;大部分情况下判断字符串是否相等指的是字符串的内容是否相等，所以采用equals方法比较。
        System.out.println("--------------------------------------");
        String s5 = "a";
        s5+="a";
        s5+="a";
        s5+="a";
        s5+="a";
        System.out.println(s5);//s5的字符串在内存中开辟了4个空间，只有最后一个空间是有效空间，比较耗性能。
        StringBuffer stringBuffer  =new StringBuffer("hello");
//        append方法表示追加内容
        stringBuffer.append("hello");
        stringBuffer.append("hello");
        stringBuffer.append("hello");
        stringBuffer.append("hello");
        System.out.println(stringBuffer);//stringBuffer字符串的内容也是变换了4次，但是每次的变换都是在同一个空间中更新内容
        //insert方法，用于在指定位置插入数据
        stringBuffer.insert(3,"嗨嗨嗨");
        System.out.println(stringBuffer);
        //delete方法，用于在指定位置删除数据
        stringBuffer.delete(9,14);
        System.out.println(stringBuffer);
    }
}

package com.kg.test;

/**
 * @author ZRB
 * @description
 * @date 2023/8/22 16:00
 */
public class Test12 {
    public static void main(String[] args) {
        // 创建一个空的StringBuilder对象
        StringBuilder str = new StringBuilder();

        // 追加字符串
        str.append("123456789876543210");

        // 从后往前每隔三位插入逗号
        int last = str.length();
        for(int i = last - 3; i > 0; i-=3) {
            str.insert(i,',');
        }
        // 将StringBuilder对象转换为String对象并输出
        System.out.print(str.toString());
    }
}

1.4.2字母字符串忽略大小写比较

package com.kg.test;


/**
 * @author ZRB
 * @description :string字符串
 * @date 2023/8/23 8:31
 */
public class Test01 {
    public static void main(String[] args) {
        String s1 = "AbCdFerrO";
        //toLowerCase方法，用于返回一个字符串的小写内容。注意：原内容并没有发生变化，它只是返回了一个副本。
        System.out.println(s1.toLowerCase());
        //toLowerCase方法，用于返回一个字符串的大写内容。注意：原内容并没有发生变化，它只是返回了一个副本。
        System.out.println(s1.toUpperCase());
        String s2 = "AbCdEfG";
        String s3 = "aBcDeFg";
        //对两个字符串的内容进行忽略大小写比较
        System.out.println(s2.toUpperCase().equals(s3.toUpperCase()));
        System.out.println(s3.toLowerCase().equals(s3.toLowerCase()));
        //equalsIgnoreCase方法，用于忽略大小写比较字符串的内容是否相等
        System.out.println(s2.equalsIgnoreCase(s3));
    }
}

1.15字符串常用方法

package com.kg.test;

/**
 * @author ZRB
 * @description:字符串的常用方法
 * @date 2023/8/23 8:59
 */
public class Test03 {
    public static void main(String[] args) {
        String s1= "hello";
        String s2 = "word";
        //concat方法是对两个字符串进行拼接,等同于“+”;
        String s3 = s1.concat(s2);
        System.out.println(s3);
        System.out.println("-----------------------------------------------");
        String s4 = "aaa您好不不不cccccdddd";
        //indexOf方法，用于从头开始查询指定的字符串在原始字符串中第一次出现的位置，如果没找到返回-1
        System.out.println(s4.indexOf("不不不"));
        //lastIndexOf方法，用于从头开始查询指定的字符串在原始字符串中最后一次次出现的位置，如果没找到返回-1
        System.out.println(s4.lastIndexOf("ddd"));
        System.out.println("---------------------------------------------");
        //substring方法，用于根据指定的索引范围在原始字符串中截取一段字符串
        //注意：传两个参数时，第一个参数的起始位置，第二个参数是结束位置，能能取到起始位置，取不到结束位置。
        String s5 = s4.substring(3,5);
        System.out.println(s5);
        //注意：如果只传一参数，这个参数表示从起始位置到醉胡位置全部截取
        String s6 =s4.substring(8);
        System.out.println(s6);
        //注意：该方法是返回一个字符串的副本，对原始字符串没有影响
        System.out.println(s4);

    }
}

1.16 Math类

java.lang.Math类提供了常用的数学运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值
public static double floor(double a)	返回小于或等于参数的最大double值
public static int round(float a)	按照四舍五入返回最接近参数的int
public static int max(int a,int b)	返回两个int值中的较大值
public static int min(int a,int b)	返回两个int值中的较小值
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的正值，[0.0,1.0)

lepackage com.kg.test;

/**
 * @author ZRB
 * @description:math类
 * @date 2023/8/23 9:48
 */
public class Test05 {
    public static void main(String[] args) {
        //Math类提供了常用的数学运算方法和两个静态常量E(自然对数的底数)和PI（圆周率)
        System.out.println(Math.E);
        System.out.println(Math.PI);
        System.out.println("---------------------------------------------");
        System.out.println(Math.abs(-100));//abs方法返回绝对值
        System.out.println(Math.ceil(55.11));//ceil方法表示向上取整，只要有小数就进一
        System.out.println(Math.floor(55.99));//floor方法表示向下取整，只要有小数就去掉
        System.out.println(Math.round(55.45));//round方法用于四舍五入
        System.out.println(Math.max(100,100.1));//max方法用于从两个数中返回较大数
        System.out.println(Math.min(100,99.8));//min方法用于从两个数中返回较小数
        System.out.println(Math.pow(2,11));//pow方法表示返回指定数的指定次方值
        System.out.println(Math.random());//randow方法表示用于返回0到1之间的随机数
    }
}

1.17 Random类

生成随机数的其他方式
java.util.Random类

package com.kg.test;

import java.util.Random;

/**
 * @author ZRB
 * @description:random类
 * @date 2023/8/23 10:50
 */
public class Test08 {
    public static void main(String[] args) {
        Random random =new Random();
        int num1 = random.nextInt();
        System.out.println(num1);
        int num2= random.nextInt(10);//指定随机数的最大范围
        System.out.println(num2);
        //随机返回一个0-1之间的随机数
        double num3= random.nextDouble();
        System.out.println(num3);
    }
}

1.18 Date类

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日 00:00:00 到现在的毫秒数
public void setTime(long time)	设置时间，给的是毫秒值

package com.kg.test;

import java.util.Date;

/**
 * @author ZRB
 * @description：data类
 * @date 2023/8/23 10:55
 */
public class Test09 {
    public static void main(String[] args) {
        //直接创建date对象返回的是系统当前时间
        Date date =new Date();
        System.out.println(date);
        //根据指定的时问股创建一个日期对象，时间股是从1970-1-1开始的毫秒数
        Date date1 = new Date(123412332);
        System.out.println(date1);
        //返回指定日期的时间戳
        long times = date1.getTime();
        System.out.println(times);
        //根据指定的时间戳重新设置日期
        date1.setTime(123);
        System.out.println(date1);
    }
}

1.8.1 SimpleDateFormat 类概述

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析

日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从’A’到’Z’以及从’a’到’z’引号的字母被解释为表示日期或时间字符串的组件模式字母

常用的模式字母以及对应关系如：y 年、M 月、d 日、H 时、m 分、s 秒

package com.kg.test;

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

/**
 * @author ZRB
 * @description:SimpleDateFormat 构造方法
 * @date 2023/8/23 11:04
 */
public class Test10 {
    public static void main(String[] args) {
        //SimpleDateFormat 类：用于格式化和解析日期
        Date date =new Date();
        /**
         * 创建格式化对象，通过构造函数设置日期的格式
         * 在创建如果格式化对象时，这里使用的日期和时间模式字符串，每个模式字符串的含义如下：
         * y表示年、m表示月、d表示日
         */
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
        String time1 = simpleDateFormat.format(date);
        System.out.println(time1);
    }
}

方法名	描述
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat，使用给定的模式和默认的日期格式

1.19 Calendar类

Calendar 为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar 提供了一个类方法 getInstance 用于获取 Calendar 对象，其日历字段已使用当前日期和时间初始化

Calendar rightNow = Calendar.getInstance();

package com.kg.test;

import java.util.Calendar;

/**
 * @author ZRB
 * @description:calendar类，日历
 * @date 2023/8/23 11:14
 */
public class Test11 {
    /*
    Calendar类、提供了获取和设置日期指定部分的方法
    通过getInstance方法，创建并返回一个日历对象
     */
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        //添加3年
        calendar.add(Calendar.YEAR,3);
        calendar.set(2012,11,12,12,12,12);
        //获取年份、月份、月的天数
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH)+1;
        //注意:这里获取的月份是8-11,0表示1月份，11表示12月份，所以我们会在获取的月份上+1;
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "-" + month + "-" + day);
        //返回全年的第多少天
        int day1 = calendar.get(Calendar.DAY_OF_YEAR);
        //返回周几：注意。第一天是周日
        int day2 = calendar.get(Calendar.DAY_OF_WEEK)-1;
        int year1 = calendar.get(Calendar.YEAR);
        System.out.println("今天是全年的第:" + day1 + "天");
        System.out.println("今天是周几:" + day2);
    }
}

方法或属性	说明
int get(int field)	返回给定日历字段的值
MONTH	指示月
DAY_OF_MONTH	指示一个月中的某天
DAY_OF_WEEK	指示一个星期中的某天
public final void set(int year,int month,int date)	设置当前日历的年月日
public abstract void add(int field,int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段

玖霆

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java高级程序笔记（1）

List集合概述有序集合（也称序列），用户可以精确控制列表中每个元素插入位置，用户可以通过整数索引访问元素，并搜索列表的元素。与set集合不同，列表通常允许重复的元素/*** 创建一个list集合，list是collection的子接口，collection的所有方法它都有* list提供根据索引操作集合元素的方法//list集合可以根据下标添加元素 System . out . println(list);
复制链接

扫一扫