JAVASE学习笔记（二）

已于 2022-02-24 14:55:25 修改
阅读量253 收藏
点赞数
文章标签： java
于 2022-02-11 20:34:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51465135/article/details/122878227
版权

七、多线程

在这里插入图片描述

基本概念：程序、进程、线程、并行、并发

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

线程的创建与启动

在这里插入图片描述
在这里插入图片描述

package Thread;
//继承的方式创建多线程
//1.创建一个继承于Thread类的子类
class Mythread extends Thread{
    //2.重写run方法-->将此线程执行的操作声明在run()中
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        Mythread mythread = new Mythread();
        //4.通过此对象调用start()：①启动当前线程②调用当前线程的run()
        mythread.start();
        //5.多线程测试
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println("hello main");
            }
        }
    }
}

练习：

package exer;
//练习：一个线程遍历100以内偶数，另一个线程遍历一百以内奇数
public class ThreadDemo {
    public static void main(String[] args){
        //方式一：创建对象方式启动线程
//        Mythread1 mythread1 = new Mythread1();
//        Mythread2 mythread2 = new Mythread2();
//        mythread1.start();
//        mythread2.start();
        //方式二：创建Thread类的匿名子类方式启动线程
        new Thread(){
            public void run(){
                for (int i = 0; i < 100; i++) {
                    if (i%2!=0){
                        System.out.println(Thread.currentThread().getName()+":"+i+"为奇数");
                    }
            }
        }
    }.start();
        new Thread(){
            public void run(){
                for (int i = 0; i < 100; i++) {
                    if (i%2==0){
                        System.out.println(Thread.currentThread().getName()+":"+i+"为偶数");
                    }
                }
            }
        }.start();
    }
}
class Mythread1 extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i+"为奇数");
            }
        }
    }
}
class Mythread2 extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i+"为偶数");
            }
        }
    }
}

Thread类常用方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Thread;
class HelloThread extends Thread{
    //构造器
    public HelloThread(String name){
        super(name);
    }
    public void run(){
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            //yield释放当前线程执行权
            if (i%20==0){
                this.yield();
            }
        }
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) throws InterruptedException {
        HelloThread helloThread = new HelloThread("线程一");
//        helloThread.setName("线程一");
        helloThread.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");

        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i==20){
                helloThread.join();
            }
        }
        System.out.println(helloThread.isAlive());
    }
}

线程的优先级

在这里插入图片描述
在这里插入图片描述
例题：创建三个取票窗口

//方式一：
package Thread;
class window extends Thread{
    private static int ticket=100;
    public void run(){
        while (true){
            if (ticket>0){
                System.out.println(getName()+":卖票，票号为："+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

创建多线程方式二：runnable接口

在这里插入图片描述

package Thread;
//1.创建一个实现Runnable接口的类
class MThread implements Runnable{
    //2.实现类实现Runnable中的抽象方法run()
    public void run(){
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        //5.通过Thread类对象调用start()
        t1.start();
        //再启动一个线程，遍历100以内的偶数
        Thread t2= new Thread(mThread);
        t2.start();
    }
}

例题：创建三个取票窗口

//方式二
package Thread;
class window1 implements Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+":"+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        window1 w1 = new window1();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

线程的生命周期

在这里插入图片描述在这里插入图片描述

线程同步（线程的安全问题）

在这里插入图片描述

同步代码块解决Runnable接口线程安全问题

在这里插入图片描述在这里插入图片描述在这里插入图片描述

package Thread;
class window1 implements Runnable{
    private int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        window1 w1 = new window1();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

同步代码块解决继承Thread类线程安全问题

package Thread;
class window extends Thread{
    private static int ticket=100;
    static Object obj=new Object();
    public void run(){
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

同步方法解决Runnable接口线程安全问题

package Thread;
class window1 implements Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while (true) {
                show();
            }
    }
    private synchronized void show(){
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + ticket);
            ticket--;
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        window1 w1 = new window1();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

同步方法解决继承Thread类线程安全问题

package Thread;
class window extends Thread{
    private static int ticket=100;
    public void run(){
        while (true) {
             show();
        }
    }
    private static synchronized void show(){//需设置为静态
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + ticket);
            ticket--;
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

线程的死锁

在这里插入图片描述

package Thread;

public class ThreadTest2 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){//匿名式创建线程一
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {//增加死锁概率
                        Thread.sleep(100);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(new Runnable() {//匿名式创建线程二
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("C");
                    s2.append("3");
                    try {//增加死锁概率
                        Thread.sleep(100);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("D");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

LOCK锁解决线程安全问题

在这里插入图片描述

package Thread;

import java.util.concurrent.locks.ReentrantLock;

class window2 implements Runnable{
    private int ticket=100;
    //1.实例化
    protected ReentrantLock lock=new ReentrantLock();
    public void run(){
        while (true){
            try {
                //2.调用锁定方法
                lock.lock();
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":售票，票号为："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //3.调用解锁方法
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        window2 w1=new window2();
        Thread t1=new Thread(w1);
        Thread t2=new Thread(w1);
        Thread t3=new Thread(w1);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述

package Thread;
class Account{
    private double balance;//余额变量
    public Account(double balance){//构造器
        this.balance=balance;
    }
    //存钱方法
    public synchronized void deposit(double amt){
        if (amt>0){
            balance+=amt;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"存钱成功：存钱金额为"+amt+"元，余额为："+balance+"元");
        }
    }
}
class Customer extends Thread{//多线程用户管理
    private Account account;
    public Customer(Account account){
        this.account=account;
    }
    public void run(){
        for (int i = 0; i < 3; i++) {
            account.deposit(1000);
        }
    }
}
public class EXER {
    public static void main(String[] args) {
        Account account = new Account(0);
        Customer c1=new Customer(account);
        Customer c2=new Customer(account);
        c1.setName("甲");
        c2.setName("乙");
        c1.start();
        c2.start();
    }
}

线程的通信

在这里插入图片描述
在这里插入图片描述

package Thread;
class print implements Runnable{
    private static int number=1;
    public void run(){
        while (true) {
            synchronized (this) {//同步
                this.notify();//唤醒
                if (number<=100){
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number+=1;
                    try {
                        this.wait();//wait()方法使得当前线程进入阻塞状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }
    }
}
public  class Tem {
    public static void main(String[] args) {
        print p1 = new print();
        Thread t1 = new Thread(p1);
        Thread t2 = new Thread(p1);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}

在这里插入图片描述在这里插入图片描述

package Thread;

class Clerk{//店员
    private int productCount=0;
    public synchronized void prduceProduct() {
        if (productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumeProduct() {
        if (productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{//生产者
    private Clerk clerk;
    public Producer(Clerk clerk){
        this.clerk=clerk;
    }
    public void run(){
        System.out.println(getName()+":开始生产产品");
        while (true){
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.prduceProduct();
        }
    }
}
class Consumer extends Thread{//消费者
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }
    public void run(){
        System.out.println(getName()+":开始消费产品");
        while (true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer P1=new Producer(clerk);
        P1.setName("生产者1");
        Consumer C1=new Consumer(clerk);
        C1.setName("消费者1");
        Consumer C2=new Consumer(clerk);
        C2.setName("消费者2");
        P1.start();
        C1.start();
        C2.start();
    }
}

新增的线程创建方式

实现Callable接口

在这里插入图片描述在这里插入图片描述

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建实现Callable的实现类
class NumThread implements Callable{
    // 2. 实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; i <= 100; i++) {
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将Callable接口实现类的对象作为参数传递到FutureTask构造器中，
        // 创建FutureTask的对象
        FutureTask futureTask = new FutureTask<>(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，
        // 创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取call方法的返回值
            //get方法返回值为call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程池

在这里插入图片描述在这里插入图片描述

package Thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Number implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class Number1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //设置线程池属性
//        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//强转为ThreadPoolExecutor类
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
        //2.执行指定线程的操作。需要提供实现Runnable接口的实现类对象
        service.execute(new Number());//适合使用于Runnalbe
        service.execute(new Number1());
//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭线程池
        service.shutdown();
    }
}

八、常用类

在这里插入图片描述在这里插入图片描述

字符串相关的类String

String的特性

在这里插入图片描述在这里插入图片描述在这里插入图片描述

package String;

public class StringTest  {
    public static void main(String[] args) {
        String s1="abc";
        String s2="abc";
        System.out.println(s1==s2);//比较地址值
        s2="hello";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("************");
        String s3="abc";
        s3+="def";
        System.out.println(s3);
        System.out.println("************");
        String s4="abc";
        String s5=s4.replace('a','m');
        System.out.println(s4);
        System.out.println(s5);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package String;

class Person{
    String name;
    int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
}
public class StringTest  {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常理池中
        String s1="JavaEE";
        String s2="JavaEE";
        //通过new+构造器的方式：此时s3和s4保存的地址值，
        //                  是数据在堆空间中开辟空间以后的地址值
        String s3=new String("JavaEE");
        String s4=new String("JavaEE");

        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s3==s4);//false
        System.out.println("*****************");
        Person person1 = new Person("Tom",12);//字面量的方式定义
        Person person2 = new Person("Tom",12);
        System.out.println(person1.name.equals(person2.name));//true(equals内容一样都为true)
        System.out.println(person1.name==person2.name);//true
        System.out.println(person1.age==person2.age);//true
    }
}

在这里插入图片描述
在这里插入图片描述

String常用方法

在这里插入图片描述

package String;

public class StringMethodTest {
    public static void test(){
        String s1="Helloworld";
        System.out.println(s1.length());
        System.out.println(s1.charAt(0));//返回某索引处的字符
        System.out.println(s1.isEmpty());//判断是否为空字符串
        System.out.println(s1.toLowerCase());//改成小写
        System.out.println(s1.toUpperCase());//改成大写
        System.out.println(s1);//s1不可变，仍然为原来的字符串

        String s2="   he llo world  ";
        System.out.println(s2.trim());//去除首尾空格

        String s3="HelloWorld";
        String s4="helloworld";
        System.out.println(s3.equals(s4));
        System.out.println(s3.equalsIgnoreCase(s4));//忽略大小写

        String s5="java:";
        System.out.println(s5.concat(s3));//指定字符串连接到此字符串的结尾

        System.out.println(s3.compareTo(s4));//比较两个字符串的大小

        System.out.println(s3.substring(5));//返回一个新的子字符串
        System.out.println(s3.substring(2, 5));//返回一个新的子字符串
    }

    public static void main(String[] args) {
        test();
    }
}

在这里插入图片描述

package String;

public class StringMethodTest {
    public static void test(){
        String s1="Helloworld";
        System.out.println(s1.startsWith("He"));//判断是否以指定前缀开始
        System.out.println(s1.startsWith("ll", 2));//判断是否从指定索引开始的子字符串是否符合指定字符
        System.out.println(s1.endsWith("ld"));//判断是否以指定后缀结束
        System.out.println(s1.contains("llow"));//判断是否包含指定子字符串
        System.out.println(s1.indexOf("lo"));//返回子字符串第一次出现的索引
        System.out.println(s1.indexOf("lo", 5));//返回指定索引后子字符串第一次出现的索引
        System.out.println(s1.lastIndexOf("lo"));//返回指定子字符串在此字符串中最右边出现处的索引
        
    }

    public static void main(String[] args) {
        test();
    }
}

在这里插入图片描述

package String;

public class StringMethodTest {
    public static void test(){
        String s1="北京2022冬奥会";
        //替换
        System.out.println(s1.replace("2022冬奥会", "2008奥运会"));
        //用正则表达式替换
        String s2="12helloworld5java7891mysql456";
        System.out.println(s2.replaceAll("\\d+", ",").replaceAll("^,|,$",""));
        //用正则表达式匹配
        String s3="0571-4534289";
        System.out.println(s3.matches("\\d+"));//判断是否全为数字
        System.out.println(s3.matches("0571-\\d{7,8}"));//判断格式要求是否匹配
        //用正则表达式切片
        String s4="hello|world|java";
        String[] split = s4.split("\\|");
        for (int i=0;i<split.length;i++){
            System.out.println(split[i]);
        }
    }

    public static void main(String[] args) {
        test();
    }

String与其他基本数据类型的转换

在这里插入图片描述

package String;

import java.util.Arrays;

public class StringTest1 {
    public static void test(){
        String s1="123";
        //String<-->基本数据类型
//        int num=(int)s1;//错误
        int num=Integer.parseInt(s1);//使用包装类转换
        String s2=String.valueOf(num);//int转为String
        System.out.println(s2);
        //String<-->char
        String s3="abc123";
        char[] chars = s3.toCharArray();
        System.out.println(chars);
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
        String s4 = new String(chars);
        System.out.println(s4);
        //String<-->byte[]
        byte[] bytes = s3.getBytes();
        System.out.println(Arrays.toString(bytes));
        System.out.println(new String(bytes)); 
    }

    public static void main(String[] args) {
        test();
    }
}

StringBuffer、StringBuilder可变的字符序列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package String;

public class StringBufferTest {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        StringBuffer s1 = new StringBuffer("ABC");
        s1.append(1);
        System.out.println(s1);
        s1.delete(2,4);
        System.out.println(s1);
        s1.replace(0,2,"hello");
        System.out.println(s1);
        s1.insert(0,"say ");
        System.out.println(s1);
//        s1.reverse();
//        System.out.println(s1);
        String s2=s1.substring(4,9);
        System.out.println(s2);
        s1.setCharAt(3,',');
        System.out.println(s1);
    }
}

日期时间的API

在这里插入图片描述
在这里插入图片描述

package JAVA;

import java.util.Date;

public class DateTimeTest {
    public static void main(String[] args) {
        //1.System类中currentTimeMillis()
        //返回当前时间与1970.1.1零时刻之间以毫秒为单位的时间查
        System.out.println(System.currentTimeMillis());//时间戳

        //2.Data类
        Date date = new Date();
        System.out.println(date.toString());//显示当前年月日时分秒
        System.out.println(date.getTime());//时间戳
        Date date1 = new Date(1645325031512L);//创建指定时间戳的年月日时分秒
        System.out.println(date1.toString());

        //3.创建java.sql.Date对象
        java.sql.Date date2 = new java.sql.Date(1645325031512L);
        System.out.println(date2.toString());//2022-02-20

        //4.如何将java.util.Date对象转换为java.sql.Date对象
        Date date3 = new Date();
        java.sql.Date date4 = new java.sql.Date(date3.getTime());
    }
}

在这里插入图片描述

package JAVA;

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

public class SimpleDateFormatTest {
    public static void main(String[] args) {
        //实例化SimpleDateFormat
        SimpleDateFormat sdf = new SimpleDateFormat();
        //日期--->字符串
        Date date = new Date();
        //格式化
        String format = sdf.format(date);
        System.out.println(format);
        //解析:字符串--》日期
        String str="2022/2/20 下午4:09";
        Date parse = null;
        try {
            parse = sdf.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(parse);
        System.out.println("****************");
        //自定义格式
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
        String format1 = sdf1.format(date);
        System.out.println(format1);
        Date parse1 = null;//解析
        try {
            parse1 = sdf1.parse("2022-20-20 04:20:57");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(parse1);
        //练习一：将字符串转为java.sql.Date
        String birth="2020-09-08";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date parse2 = null;
        try {
            parse2 = simpleDateFormat.parse(birth);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        java.sql.Date date1 = new java.sql.Date(parse2.getTime());
        System.out.println(date1);

    }
}

在这里插入图片描述

package JAVA;

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

public class CalendarTest {
    public static void main(String[] args) {
        //1.实例化
        //方式一：创建其子类的对象
        //方式二：调用静态方法getInstance()
        Calendar instance = Calendar.getInstance();
//        System.out.println(instance.getClass());
        //2.常用方法
        //get()
        System.out.println(instance.get(Calendar.DAY_OF_MONTH));
        System.out.println(instance.get(Calendar.DAY_OF_YEAR));
        //set()
        instance.set(Calendar.DAY_OF_MONTH,22);
        int days = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
        //add()
        instance.add(Calendar.DAY_OF_MONTH,3);
        System.out.println(instance.get(Calendar.DAY_OF_MONTH));
        //getTime()
        System.out.println(instance.getTime());
        //setTime()
        Date date = new Date();
        instance.setTime(date);
        System.out.println(instance.get(Calendar.DAY_OF_MONTH));
    }
}

在这里插入图片描述
在这里插入图片描述
★★★★★
在这里插入图片描述
在这里插入图片描述

package JAVA;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class LocalTimeTest {
    public static void main(String[] args) {
        //now():获取当前的日期、时间、日期+时间
        LocalDate now = LocalDate.now();
        LocalTime now1 = LocalTime.now();
        LocalDateTime now2 = LocalDateTime.now();
        System.out.println(now);
        System.out.println(now1);
        System.out.println(now2);
        //of():设置指定年月日时分秒
        LocalDateTime of1 = LocalDateTime.of(2022, 2, 21, 10, 37);
        System.out.println(of1);
        //getXxx()：获取相关属性
        System.out.println(now.getDayOfMonth());
        System.out.println(now1.getHour());
        System.out.println(now2.getDayOfYear());
        //体现local的不可变性
        //with():设置相关的属性
        LocalDate localDate = now.withDayOfMonth(3);
        System.out.println(now);
        System.out.println(localDate);
        LocalTime localTime = now1.withHour(12);
        System.out.println(now1);
        System.out.println(localTime);
        //plus():加
        LocalDate localDate1 = now.plusDays(2);
        System.out.println(now);
        System.out.println(localDate1);
        //minus():减
        LocalTime localTime1 = now1.minusHours(2);
        System.out.println(now1);
        System.out.println(localTime1);

    }
}

在这里插入图片描述
在这里插入图片描述

package JAVA;

import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

public class instantTest {
    public static void main(String[] args) {
        //now()获取本初子午线的时间
        Instant now = Instant.now();
        System.out.println(now);
        //添加时间偏移量
        OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);
        //toEpochMilli():获取1970年1月1日0时0秒（UTC）开始的毫秒数
        long l = now.toEpochMilli();
        System.out.println(l);
        //ofEpochMilli()通过给定的毫秒数获取Instant实例
        Instant instant = now.ofEpochMilli(1645428712012L);
        System.out.println(instant);
    }
}

在这里插入图片描述

package JAVA;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

public class DateTimeFormatterTest {
    public static void main(String[] args) {
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化：日期--》字符串
        LocalDateTime now = LocalDateTime.now();
        String format = formatter.format(now);
        System.out.println(now);
        System.out.println(format);
        //解析：字符串--》日期
        TemporalAccessor parse = formatter.parse("2022-02-21T17:22:43.8229857");
        System.out.println(parse);

        //方式二：本地化相关的格式ofLocalizedDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);

        //格式化
        String format1 = formatter1.format(LocalDateTime.now());
        System.out.println(format1);
        String format2 = formatter2.format(LocalDate.now());
        System.out.println(format2);

        //方式三：自定义格式
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //格式化
        String format3 = formatter3.format(LocalDateTime.now());
        System.out.println(format3);
        //解析
        TemporalAccessor parse1 = formatter3.parse("2022-02-21 05:48:40");
        System.out.println(parse1);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

java比较器

在这里插入图片描述

在这里插入图片描述

package JAVA;

import java.util.Arrays;

public class CompareTest {
    public static void main(String[] args) {
       test();
    }
    public static void test(){
        String[] strings = {"aa", "dd", "cc",  "ee","bb"};
        Arrays.sort(strings);
        System.out.println(Arrays.toString(strings));//[aa, bb, cc, dd, ee]
    }
}

package JAVA;

import java.util.Arrays;

public class CompareTest {
    public static void main(String[] args) {
       test1();
    }
    public static void test1(){
        Goods[] goods = new Goods[5];
        goods[0] = new Goods("lenovo", 34);
        goods[1] = new Goods("Dell", 43);
        goods[2] = new Goods("xiaomi", 12);
        goods[3] = new Goods("huawei", 65);
        goods[4] = new Goods("Apple", 65);
        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
    }
}
public class Goods implements Comparable{
    private String name;
    private double price;
    public Goods(){

    }
    public Goods(String name,double price){
        this.name=name;
        this.price=price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

    @Override
    //商品价格按照从低到高排序
    public int compareTo(Object o) {
        if (o instanceof Goods){
            Goods o1 = (Goods) o;
            if (this.price>o1.price){
                return 1;
            }else if (this.price<o1.price){
                return -1;
            }else{
                return this.name.compareTo(o1.name);
            }
        }
        throw new RuntimeException("传入数据不一致");
    }
}

在这里插入图片描述
在这里插入图片描述

package JAVA;

import java.util.Arrays;
import java.util.Comparator;

public class CompartorTest {
    public static void main(String[] args) {
        test();
        test1();
    }
    public static void test(){
        String[] strings = {"AA", "CC", "KK", "DD", "BB"};
        //字符串从大到小顺序排列
        Arrays.sort(strings,new Comparator(){
            @Override
            public int compare(Object o1,Object o2){
                if (o1 instanceof String&&o2 instanceof String){
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
                throw new RuntimeException("输入类型不一致");
            }
        });
        System.out.println(Arrays.toString(strings));
    }
    public static void test1(){
        Goods[] goods = new Goods[6];
        goods[0] = new Goods("lenovo", 34);
        goods[1] = new Goods("lenovo", 39);
        goods[2] = new Goods("Dell", 43);
        goods[3] = new Goods("xiaomi", 12);
        goods[4] = new Goods("huawei", 65);
        goods[5] = new Goods("Apple", 65);
        //先按照产品名称从低到高，再按照价格从高到低
        Arrays.sort(goods, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Goods&& o2 instanceof Goods){
                    Goods g1 =(Goods)o1;
                    Goods g2 = (Goods) o2;
                    if (g1.getName().equals(g2.getName())){
                        return -Double.compare(g1.getPrice(),g2.getPrice());
                    }else {
                        return g1.getName().compareTo(g2.getName());
                    }
                }
                throw new RuntimeException("输入类型不一致");
            }
        });
        System.out.println(Arrays.toString(goods));
    }
}
package JAVA;

public class Goods implements Comparable{
    private String name;
    private double price;
    public Goods(){

    }
    public Goods(String name,double price){
        this.name=name;
        this.price=price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

    @Override
    //商品价格按照从低到高排序
    public int compareTo(Object o) {
        if (o instanceof Goods){
            Goods o1 = (Goods) o;
            if (this.price>o1.price){
                return 1;
            }else if (this.price<o1.price){
                return -1;
            }else{
                return this.name.compareTo(o1.name);
            }
        }
        throw new RuntimeException("传入数据不一致");
    }
}

System类、Math类

在这里插入图片描述
在这里插入图片描述

package JAVA;

public class OtherClass {
    public static void main(String[] args) {
        String version = System.getProperty("java.version");
        System.out.println("java.version:"+version);

        String home = System.getProperty("java.home");
        System.out.println("java.home:"+home);

        String osname = System.getProperty("os.name");
        System.out.println("os.name:"+osname);

        String osversion = System.getProperty("os.version");
        System.out.println("os.versiong:"+osversion);

        String username = System.getProperty("user.name");
        System.out.println("username:"+username);

        String usedir = System.getProperty("use.dir");
        System.out.println("usedir:"+usedir);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package JAVA;

import java.math.BigDecimal;
import java.math.BigInteger;

public class OtherClass {
    public static void main(String[] args) {
        BigInteger bigInteger = new BigInteger("1324561321564303545312035431053430");
        BigDecimal bigDecimal = new BigDecimal("1354310.2651");
        BigDecimal bigDecimal1 = new BigDecimal("11");

        System.out.println(bigInteger);
        System.out.println(bigDecimal.divide(bigDecimal1));
        System.out.println(bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_HALF_UP));//四舍五入
        System.out.println(bigDecimal.divide(bigDecimal1, 15, BigDecimal.ROUND_HALF_UP));//任意精度
    }
}

九、枚举类与注解

枚举类的使用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package meijuclass;
//自定义枚举类
public class SeasonTest {
    public static void main(String[] args) {
        Season spring=Season.spring;
        System.out.println(spring);
    }
}
class Season{
    //1.声明Season对象的属性：private final属性
    private final String seasonName;
    private final String seasonDesc;
    //2.私有化类的构造器，并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName=seasonName;
        this.seasonDesc=seasonDesc;
    }
    //3.创建枚举类的多个对象：private static final的
    public static final Season spring=new Season("春天","春暖花开");
    public static final Season summer=new Season("夏天","夏日炎炎");
    public static final Season autumn=new Season("秋天","秋高气爽");
    public static final Season winter=new Season("冬天","冰雪皑皑");
    //4.获取枚举类对象的属性
    public String getSeasonName(){
        return seasonName;
    }
    public String getSeasonDesc(){
        return seasonDesc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

在这里插入图片描述

package meijuclass;
//enum枚举类
public class SeasonTest {
    public static void main(String[] args) {
        Season spring=Season.spring;
        System.out.println(spring);
        //toString():
        System.out.println(spring.toString());
        //values():
        Season[] values = Season.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }
        //valueof(String ObjName):返回枚举类中对象名是ObjName的对象
        Season winter=Season.valueOf("winter");
        System.out.println(winter);

    }
}
enum Season{
    //1.提供当前枚举类的对象，多个对象","隔开";"结束
    spring("春天","春暖花开"),
    summer("夏天","夏日炎炎"),
    autumn("秋天","秋高气爽"),
    winter("冬天","冰雪皑皑");
    //2.声明Season对象的属性：private final属性
    private final String seasonName;
    private final String seasonDesc;
    //3.私有化类的构造器，并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName=seasonName;
        this.seasonDesc=seasonDesc;
    }
    //4.获取枚举类对象的属性
    public String getSeasonName(){
        return seasonName;
    }
    public String getSeasonDesc(){
        return seasonDesc;
    }
}

在这里插入图片描述

package meijuclass;
//enum枚举类
public class SeasonTest {
    public static void main(String[] args) {
        Season spring=Season.spring;
        System.out.println(spring);
        //toString():
        System.out.println(spring.toString());
        //values():
        Season[] values = Season.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
            values[i].show();
        }
        //valueof(String ObjName):返回枚举类中对象名是ObjName的对象
        Season winter=Season.valueOf("winter");
        System.out.println(winter);
        winter.show();
    }
}
interface info{
    void  show();
}
enum Season implements info {
    //1.提供当前枚举类的对象，多个对象","隔开";"结束
    spring("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("这是春天");
        }
    },
    summer("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("这是夏天");
        }
    },
    autumn("秋天","秋高气爽"){
        @Override
        public void show() {
            System.out.println("这是秋天");
        }
    },
    winter("冬天","冰雪皑皑"){
        @Override
        public void show() {
            System.out.println("这是冬天");
        }
    };
    //2.声明Season对象的属性：private final属性
    private final String seasonName;
    private final String seasonDesc;
    //3.私有化类的构造器，并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName=seasonName;
        this.seasonDesc=seasonDesc;
    }
    //4.获取枚举类对象的属性
    public String getSeasonName(){
        return seasonName;
    }
    public String getSeasonDesc(){
        return seasonDesc;
    }

    public void show(){
        System.out.println("季节");
    }
}

注解

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

十、集合（数据存储）★

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Collection接口的方法

package Collection1;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

public class CollectionTest {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        //size():获取添加元素的个数
        System.out.println(coll.size());
        //addAll():将coll集合中的元素添加到当前集合中
        Collection coll1 = new ArrayList();
        coll1.add("CC");
        coll1.add(132);
        coll1.add(coll);
        System.out.println(coll1);
        //clear():清空元素
        coll.clear();
        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());
    }
}

package Collection1;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class CollectionTest {
    public static void main(String[] args) {
//        test();
//        test1();
//        test2();
        test3();
    }
    public static void test(){
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        PersonTest jerry = new PersonTest("JERRY", 20);
        coll.add(jerry);
        
        //1.contains(Object obj):判断当前集合中是否包含obj，在判断时会调用obj对象所在类的equals()
        //                     需要重写obj所在类的equals方法
        System.out.println(coll.contains(123));
        System.out.println(coll.contains(jerry));
        System.out.println(coll.contains(new PersonTest("JERRY", 20)));
        //2.containsAll(Collection coll1)
        Collection coll1 = Arrays.asList("AA", "BB");
        System.out.println(coll.containsAll(coll1));
    }
    public static void test1(){
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        PersonTest jerry = new PersonTest("JERRY", 20);
        coll.add(jerry);
        //3.remove:移除
        coll.remove("AA");
        coll.remove(new PersonTest("JERRY", 20));
        System.out.println(coll);
        //4.removeALL(Collection coll1)：从当前集合中移除含有coll1的元素(差集)
        Collection coll1=Arrays.asList(123,"CC");
        coll.removeAll(coll1);
        System.out.println(coll);
    }
    public static void test2(){
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        PersonTest jerry = new PersonTest("JERRY", 20);
        coll.add(jerry);
        //5.retain(Collection coll1):获取当前集合与coll1集合的交集
        Collection coll1=Arrays.asList(123,456,789);
        coll.retainAll(coll1);
        System.out.println(coll);
        //6.equals:判断当前集合和形参集合元素是否相同
        Collection coll2 = Arrays.asList(123);
        System.out.println(coll.equals(coll2));
    }
    public static void test3(){
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());
        //8.集合-->数组：toArray()
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.print(objects[i]);
        }
        System.out.println();
        //数组-->集合:调用Arrays类的静态方法asList()
        List<String> strings = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(strings);
        List ints = Arrays.asList(new int[]{123, 456});//×
        System.out.println(ints);
        List integers = Arrays.asList(new Integer[]{123, 456});//√
        System.out.println(integers);
    }
}
package Collection1;

import java.util.Objects;

public class PersonTest {
    private String name;
    private int age;
    public PersonTest(){

    }
    public PersonTest(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 "PersonTest{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PersonTest that = (PersonTest) o;
        return age == that.age && Objects.equals(name, that.name);
    }
}

Iterator迭代器接口遍历集合元素

在这里插入图片描述

package Collection1;

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

public class IteratorTest {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        String jerry = new String("JERRY");
        coll.add(jerry);
        //1.hasNext()和next()
        Iterator iterator = coll.iterator();
        //方式一：不推荐
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }
        //方式二：
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //2.remove():删除集合中的元素
        Iterator iterator1 = coll.iterator();
        while (iterator1.hasNext()){
            Object obj=iterator1.next();
            if ("JERRY".equals(obj)){
                iterator1.remove();
            }
        }
        //遍历
        Iterator iterator2 = coll.iterator();
        while (iterator2.hasNext()){
            System.out.println(iterator2.next());
        }
    }
}

foreach循环遍历集合元素

在这里插入图片描述

package Collection1;

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

public class ForeachTest {
    public static void main(String[] args) {
//        test();
//        test2();
        test3();
    }
    public static void test(){
        Collection coll=new ArrayList();
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        String jerry = new String("JERRY");
        coll.add(jerry);

        //for(集合中元素的类型 局部变量 : 集合对象)
        //内部仍然调用了迭代器
        for(Object obj:coll){
            System.out.println(obj);
        }
    }
    public static void test2(){
        int[] arr=new int[]{1,2,3,4,5,6};
        for (int i:arr){
            System.out.println(i);
        }
    }
    public static void test3(){
        String[] arr=new String[]{"mm","gg","jj"};
//        //方式一：普通for循环赋值
//        for (int i = 0; i < arr.length; i++) {
//            arr[i]="mm";
//        }
//        for (int i = 0; i < arr.length; i++) {
//            System.out.println(arr[i]);
//        }
        //方式二：增强for循环赋值原arr不变
        for (String s:arr){
            s = "gg";
        }
        for (String s:arr){
            System.out.println(s);
        }
    }
}

Collection子接口：List

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

ArrayList源码分析

在这里插入图片描述

LinkedList源码分析

在这里插入图片描述

Vector源码分析

在这里插入图片描述

List接口中的常用方法

在这里插入图片描述

package Collection1;

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

public class ListTest {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        ArrayList list=new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new PersonTest("Tom",20));
        list.add(465);

        //1.add():在index位置插入元素
        list.add(2,789);
        System.out.println(list);
        //2.addALL()：
        List integers = Arrays.asList(1, 2, 3);
        list.addAll(integers);
        System.out.println(list);
        //3.get()：获取指定位置元素
        System.out.println(list.get(0));
        //4.indexof:返回集合中元素的索引位置
        System.out.println(list.indexOf(123));
        //5.remove()：
        list.remove(0);
        list.remove("AA");
        System.out.println(list);
        //6.set():设置指定位置为指定元素
        list.set(0,"AAA");
        System.out.println(list);
        //7.subList():左闭右开的子集合
        System.out.println(list.subList(1,3));
        //8.Iterator迭代器方式遍历List
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //9.增强for循环
        for (Object obj:list){
            System.out.println(obj);
        }
    }
}

Collection子接口：Set

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package Collection1;

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

//体会Set接口的无序性和不可重复性
public class SetTest {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        Set set = new HashSet();
        set.add(123);
        set.add(456);
        set.add("AA");
        set.add(new PersonTest("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

m0_51465135
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
我的javaSE学习笔记
吴甜甜的技术博客
06-14 1758
layout: post title: “我的JAVASE自学笔记” date: 2019-05-18 20:23:25 +0800 我的JAVASE自学笔记 作者：吴甜甜 个人博客网站： wutiantian.github.io 基础知识 学习书籍：《疯狂JAVA讲义》李刚 搭建命令行编译环境 下载软件jdk jdk是开发java要用到的工具，里面包括 ①jre (java ru...
非常详细javaSE学习笔记.rar
10-21
这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...
JavaSE学习笔记
Aryu的博客
09-02 627
JavaSE（进阶学习）
JavaSE学习笔记 Day11
CHiN_951的博客
12-05 950
面向对象三大特征之 多态
JavaSE学习笔记 Day7
CHiN_951的博客
12-04 986
debug、数组(初始化、遍历、默认值)
JavaSE学习笔记 Day6
CHiN_951的博客
11-30 798
方法
JavaSE学习笔记 Day10
CHiN_951的博客
12-05 884
面向对象三大特征之 封装、继承
JavaSE学习笔记 Day12
CHiN_951的博客
12-06 427
static修饰符(静态)
javaSE学习笔记全集
everything_study的博客
10-03 107
01-java基础 02-字符串笔记 03-java包的介绍 04-面向对象的笔记 05-继承的笔记 05.1-接口的笔记 06-多态的笔记 07-修饰符 08-集合 09-包装类 10-大数 11-代码块 12-常见的查找算法和分块查找的简明教程 13-树的基本知识 14-内部类笔记 15-常见的API 16-Stream流 17-正则表达式 18-Date类 19-异常的学习笔记 20-IO流基础 21-IO流提高 22-框架 23-propertie文件和XML以及dom4j的基本操作 24-日志文件
JavaSE学习笔记 Day13
CHiN_951的博客
12-07 872
接口
javaSE学习笔记_目录
PizAn的博客
12-09 3944
IO字节流 javaSE (二十九）IO.read()输出是int的原因、fileoutputstream的追加功能、用byte[]优化拷贝文件、Buffered缓冲区内存示意图 javaSE (三十）IO流异常处理、图片加密处理、输入文件路径并拷贝文件内容、在文件中键入内容 计算机基础知识 javaSE (一）数据类型转换、++/–运算符 javaSE (二）逻辑/位运算符、左移右移运算符、sw...
javase-学习笔记.pdf
11-28
javase-学习笔记.pdf
JavaSE学习笔记.rar
08-19
这个学习笔记包含了Java开发的基础阶段知识，是初学者掌握Java编程语言的关键。以下将详细解析JavaSE中的主要知识点： 1. **Java基础语法**：Java是一种强类型、面向对象的编程语言，它的基础语法包括变量声明、...
JavaSE学习笔记.docx
12-20
Java学习笔记 初识Java编程、Java基本数据类型、运算符、流程控制、数组、方法、面相对象、Java常用类库、集合、异常处理、多线程、IO流、网络编程、Java的反射机制、泛型、枚举、注解、配置文件操作、发送邮件、...
黑马程序员Javase笔记
01-18
"黑马程序员Javase笔记"是一个自学者在学习黑马程序员提供的Java全套课程过程中整理的笔记，主要涵盖了Java Standard Edition (Javase) 的核心内容。下面将详细讨论其中的关键知识点。 首先，DOS命令是操作系统中的...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1198
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 487
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
解决分布式环境下session共享问题
最新发布
shenxiaomo1688的博客
07-06 470
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
ShardingSphere
Casual_Lei的博客
07-04 617
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
javase黑马学习笔记
07-25
- *1* *2* [【学习笔记/自用】黑马程序员javase2023版-基础](https://blog.csdn.net/qq_41014040/article/details/129164451)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值