day22-java

时帆

已于 2023-04-19 16:09:28 修改

阅读量72

点赞数

分类专栏： Java 文章标签： java 数据结构

于 2023-02-21 23:23:38 首次发布

本文链接：https://blog.csdn.net/agjnhga/article/details/129152491

版权

Java 专栏收录该内容

63 篇文章 0 订阅

订阅专栏

红黑树（增删改查效率都很高）

红黑规则：

每一个节点是红色或者黑色，根节点必须是黑色
如果一个节点没有子节点或者父节点，则这个节点相应的指针属性为Nil，称为叶节点，叶节点是黑色的
如果一个节点是红色的，那么它的子节点必须是黑色的（不能出现两个红节点相连的情况）
对每一个节点，从该节点到其后代叶节点的简单路径上，黑节点的数量应相同

添加节点：

添加的节点可以为红色也可为黑色，使用红色效率高

当添加的节点是根节点时，直接变为黑色就行

当父节点是黑色时，不需要做其他操作

当父节点是红色，叔叔节点也是红色时，将父节点和叔叔节点变为黑色，祖父节点变为红色，若祖父节点是根节点，则将根节点再变为黑色

当父节点是红色，叔叔节点是黑色时，将父节点变为黑色，祖父节点变为红色，以祖父节点为支点进行旋转

Collection集合系列

概述

package com.itheima.collection.summarize;

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

/**
 * 集合概述
 * 集合只支持引用数据类型，不支持基本数据类型，基本数据类型应使用包装类
 * 集合元素类型、长度不固定，适合做增删操作
 * 集合分为单列集合Collection（每个元素只包含一个值）、双列集合Map（每个元素包含两个值，称为键值对）
 * Collection集合体系包括List集合和Set集合
 * List集合包括ArrayList、LinkedList等
 * 特点是：有序、可重复、有索引
 * Set集合包括HashSet、TreeSet、LinkedHashSet等
 * HashSet特点是：无序、不可重复、无索引
 * LinkedHashSet：有序、不可重复、无索引
 * TreeSet：按大小默认升序排列、不可重复、无索引
 */
public class Demo01Collection {
    public static void main(String[] args) {
        //有序、可重复、有索引
        Collection list = new ArrayList<>();
        list.add("java");
        list.add("java");
        list.add(3245);
        list.add(true);
        list.add(true);
        //[java, java, 3245, true, true]
        System.out.println(list);
        System.out.println("----------------------------------------");
        //无序、不可重复、无索引
        Collection list1 = new HashSet();
        list1.add("java");
        list1.add("java");
        list1.add(3245);
        list1.add(true);
        list1.add(true);
        //[java, 3245, true]
        System.out.println(list1);

//        ArrayList<String> s = new ArrayList<String>();
        ArrayList<String> s = new ArrayList<>();//从JDK7开始，后面的限制类型可省略
    }
}

常用API

package com.itheima.collection.api;

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

/**
 * Collection常用API
 */
public class Demo01 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        //1.boolean add(E e)添加元素到集合中
        list.add("java");
        list.add("HTML");
        list.add("mysql");
        //true,如果是HashSet集合就是false
        System.out.println(list.add("java"));
        //[java, HTML, mysql, java]
        System.out.println(list);

        //2.void clear()清空集合元素
        //list.clear();
        //[]
        //System.out.println(list);

        //3.boolean remove(E e)在集合中删除给定对象
        //存在多个相同元素时默认删除第一个
        list.remove("java");
        //[HTML, mysql, java]
        System.out.println(list);

        //4.boolean contains(Object o)判断是否包含给定对象
        //true
        System.out.println(list.contains("HTML"));

        //5.boolean isEmpty()判断集合是否为空
        //false
        System.out.println(list.isEmpty());

        //6.int size()返回集合中元素个数
        //3
        System.out.println(list.size());

        //7.Object[] toArray()把集合中的元素存储到数组中
        //注意：这里数组类型为Object，不能是String，因为存在强制存入非String类型对象情况
        Object[] arr = list.toArray();
        //[java, HTML, java]
        System.out.println("数组："+Arrays.toString(arr));

        System.out.println("--------------拓展---------------");
        Collection<String> list1 = new ArrayList<>();
        list1.add("赵敏");
        list1.add("殷素素");
        //把一个集合的元素全部添加到另一个集合中去
        list.addAll(list1);
        //[HTML, mysql, java, 赵敏, 殷素素]
        System.out.println(list);
        //[赵敏, 殷素素]
        System.out.println(list1);
    }
}

迭代器

package com.itheima.collection.api;

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

/**
 * 迭代器
 * 无法遍历数组
 * 继承了Iterable接口的类才可以使用迭代器和foreach循环
 */
public class Demo02Iterator {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        ((ArrayList<String>) list).add("殷素素");
        ((ArrayList<String>) list).add("张无忌");
        ((ArrayList<String>) list).add("赵敏");
        //创建迭代器对象，默认指向索引0位置
        Iterator<String> it = list.iterator();
        //判断当前位置是否有元素，避免越界异常（NoSuchElementException）
        while (it.hasNext()){
            //获取当前位置元素
            String next = it.next();
            System.out.println(next);
//            System.out.println(it.next());报错
        }
        //Collection类型不支持索引，不能用索引遍历
        for (String s : list) {
            System.out.println(s);
            if (s.equals("张无忌")){
                //修改无效
                s = "周芷若";
            }
        }
        //[殷素素, 张无忌, 赵敏]
        System.out.println(list);
    }
}

lambda遍历集合

package com.itheima.collection.api;

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

/**
 * Lambda表达式遍历集合
 * default void forEach(Consumer<? super T> action)
 */
public class Demo03Lambda {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        ((ArrayList<String>) list).add("殷素素");
        ((ArrayList<String>) list).add("张无忌");
        ((ArrayList<String>) list).add("赵敏");
        //遍历集合
//        list.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });

        //简化：
//        list.forEach(s -> System.out.println(s));
        //终极简化
        list.forEach(System.out::println);
    }
}

集合中存储自定义对象

package com.itheima.collection.api;

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

/**
 * 往集合中存储自定义类型对象
 */
public class Demo04Custom {
    public static void main(String[] args) {
        Movie movie1 = new Movie("《你好，李焕英》", 9.5, "张小斐、贾玲、沈腾、陈赫");
        Movie movie2 = new Movie("《唐人街探案》", 8.5, "王宝强、刘昊然");
        Movie movie3 = new Movie("《刺杀小说家》", 8.6, "雷佳音、杨幂");
        Collection<Movie> movies = new ArrayList<>();
        movies.add(movie1);
        movies.add(movie2);
        movies.add(movie3);
        Iterator<Movie> it = movies.iterator();
        while (it.hasNext()){
            Movie next = it.next();
            System.out.println(next.toString());
        }
    }
}

Movie类

package com.itheima.collection.api;

public class Movie {
    private String name;
    private double score;
    private String castList;

    @Override
    public String toString() {
        return "Movie{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", castList='" + castList + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getCastList() {
        return castList;
    }

    public void setCastList(String castList) {
        this.castList = castList;
    }

    public Movie() {
    }

    public Movie(String name, double score, String castList) {
        this.name = name;
        this.score = score;
        this.castList = castList;
    }
}

List系列集合

特点及常用API

package com.itheima.list;

import java.util.LinkedList;
import java.util.List;

/**
 * List系列集合特点及常用API
 * 继承了Collection集合的功能，多了一些基于索引的独有方法
 * ArrayList集合底层是基于数组实现的，根据索引查询元素快，增删相对慢
 * LikedList集合底层是基于双向链表实现的，查询元素慢，增删首尾元素非常快
 */
public class Demo01 {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("java");
        list.add("mysql");
        list.add("html");
        list.add("javascript");
        System.out.println(list);

        //1.指定位置插入指定元素
        list.add(2,"666");
        System.out.println("在索引2位置插入一个元素后："+list);

        //2.删除指定索引位置的元素，返回被删除的元素
        String s = list.remove(1);
        System.out.println("被删除的元素为："+s);
        System.out.println("删除一个元素后集合元素还有："+list);

        //3.修改指定索引位置的元素，返回被修改的元素
        String s1 = list.set(1, "html");
        System.out.println("被修改的元素为："+s1);
        System.out.println("修改索引1位置的元素后："+list);

        //4.获取指定索引位置的元素
        String s2 = list.get(3);
        System.out.println("索引3位置的元素为："+s2);
        //5.判断是否包含
        //底层是依赖equals方法进行判断是否包含,若存储的是自定义对象,则需要在javabean中重写equals方法
        boolean contains = list.contains("mysql");
		System.out.println(contains);
    }
}

List集合遍历方式

package com.itheima.list;

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

/**
 * List集合的遍历方式
 * 1.迭代器
 * 2.增强型for循环
 * 3.Lambda表达式
 * 4.for循环
 */
public class Demo02BianLi {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("java");
        list.add("html");
        list.add("js");

        //1.迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }
        System.out.println("--------------------------------------");

        //2.增强for循环
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("--------------------------------------");

        //3.Lambda表达式
        list.forEach(s-> System.out.println(s));
        System.out.println("--------------------------------------");

        //4.for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

LinkedList独有API

package com.itheima.list;

import java.util.LinkedList;

/**
 * LinkedList多了很多首尾操作的API
 * 1.E getFirst()
 * 2.E getLast()
 * 3.E removeFirst()
 * 4.E removeLast()
 * 5.void addFirst()
 * 6.void addLast()
 */
public class Demo03LinkedList {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        System.out.println(list);

        System.out.println("首部添加元素jjj");
        //首部添加元素
        list.addFirst("jjj");
        //获取首部元素
        String first = list.getFirst();
        System.out.println("首部元素:"+first);
        System.out.println(list);

        System.out.println("尾部添加元素ee");
        //尾部添加元素
        list.addLast("ee");
        //获得尾部元素
        String last = list.getLast();
        System.out.println("尾部元素："+last);
        System.out.println(list);

        System.out.println("移除首部元素");
        //移除首部元素
        list.removeFirst();
        System.out.println(list);

        System.out.println("移除尾部元素");
        //移除尾部元素
        list.removeLast();
        System.out.println(list);
        System.out.println("------------------------------------------------");
        
        //使用LinkedList做一个队列
        LinkedList<String> queue = new LinkedList<>();
        //入队
        queue.addLast("111");
        queue.addLast("222");
        queue.addLast("333");
        System.out.println(queue);
        //出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());

        //做一个栈
        LinkedList<String> stack = new LinkedList<>();
        //压栈,push同addFirst
        stack.push("aaa");
        stack.push("bbb");
        stack.push("ccc");
        System.out.println(stack);
        //弹栈，pop同removeFirst
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
    }
}

并发修改异常

package com.itheima.list;

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

/**
 * 集合遍历删除可能出现的，并发修改异常问题
 */
public class Demo04Delete {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Java");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        System.out.println(list);

        //1.使用迭代器遍历删除
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String next = it.next();
            if ("Java".equals(next)){
//                list.remove(next);使用集合删除元素会报错，ConcurrentModificationException
                  it.remove();//修改当前索引位置元素，使用迭代器的api不会报错
            }
        }
        System.out.println(list);

        ArrayList<String> list1 = new ArrayList<>();
        list1.add("Java");
        list1.add("Java");
        list1.add("bbb");
        list1.add("ccc");
        list1.add("ddd");
        System.out.println(list1);

        //2.使用foreach循环遍历删除,会出问题，且无法解决
//        for (String s : list) {
//            if ("Java".equals(s)){
//                list.remove(next);使用集合删除元素会报错，ConcurrentModificationException
//            }
//        }

        //3.使用lambda表达式遍历删除,和foreach循环一样
//        list.forEach(s -> {if ("Java".equals(s)){
//                list.remove(s);//使用集合删除元素会报错，ConcurrentModificationException
//        }});

        //4.for循环遍历删除，从后面边遍历边删除才没问题
        for (int i = list.size()-1; i >=0 ; i--) {
            String s = list.get(i);
            if ("Java".equals(s)){
                list.remove(s);
            }
        }
        System.out.println(list);
    }
}

泛型

泛型类

package com.itheima.genericity;

import com.itheima.genericity.demo01domain.MyArrayList;

/**
 * 模拟ArrayList集合自定义一个集合MyArrayList集合
 * 完成添加和删除功能的泛型设计即可。
 */
public class Demo01GenericityClass {
    public static void main(String[] args) {
        MyArrayList<String> myList = new MyArrayList<>();
        myList.add("java");
        myList.add("java3");
        myList.add("java1");
        System.out.println(myList.toString());
        myList.remove("java");
        System.out.println(myList.toString());
    }
}

MyArrayList类

package com.itheima.genericity.demo01domain;

import java.util.ArrayList;

public class MyArrayList<T> {
    //外部对象里面装一个对象
    private ArrayList<T> list = new ArrayList<>();
    public void add(T t){
        list.add(t);
    }
    public void remove(T t){
        list.remove(t);
    }

    @Override
    public String toString() {
        return list.toString();
    }
}

泛型方法

package com.itheima.genericity;

/**
 * 泛型方法
 * 核心思想：将所有出现泛型变量的地方全部替换为真实数据类型
 * 作用：方法中可以使用泛型接收一切实际类型的参数，方法更具通用性
 */
public class Demo02GenericityMethod {
    public static void main(String[] args) {
        Integer[] arr = {1,5,3,6,4};
        printArr(arr);
        String[] arr1 = {"sf","fa","gbv"};
        printArr(arr1);
    }
    /**
     * 需求：接收一个任意类型的数组，实现Arrays.toString(数组)功能
     */
    public static <E> void printArr(E[] arr){
        if (arr!=null){
            StringBuilder s = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                    s.append(arr[i]).append(i == arr.length-1?"":",");
            }
            s.append("]");
            System.out.println(s.toString());
        }else {
            System.out.println(arr);
        }

    }
}

泛型接口

package com.itheima.genericity;

/**
 * 泛型接口
 * 作用：可以约束实现类，实现类在实现接口的时候可以传入自己操作的数据类型
 * 这样重写的方法都将是针对于该类型的操作
 * @param <E>
 */
public interface Demo03GenericityInterface<E> {
    void add(E e);
    void delete(E e);
    E queryId(int id);
}

Teacher类

package com.itheima.genericity.demo03domain;

public class Teacher {
}

Student类

package com.itheima.genericity.demo03domain;

public class Student {
}

StudentData类

package com.itheima.genericity.demo03domain;

import com.itheima.genericity.Demo03GenericityInterface;

public class StudentData implements Demo03GenericityInterface<Student> {
    @Override
    public void add(Student student) {

    }

    @Override
    public void delete(Student student) {

    }

    @Override
    public Student queryId(int id) {
        return null;
    }
}

TeacherData类

package com.itheima.genericity.demo03domain;

import com.itheima.genericity.Demo03GenericityInterface;

public class TeacherData implements Demo03GenericityInterface {
    @Override
    public void add(Object o) {

    }

    @Override
    public void delete(Object o) {

    }

    @Override
    public Object queryId(int id) {
        return null;
    }
}

通配符

package com.itheima.genericity;

import java.util.ArrayList;

/**
 * 通配符：?
 * 作用：可以在使用泛型的时候表示一切类型
 * 泛型上限：? extends Car：?必须是Car类型或者其子类
 * 泛型下限：? super Car：?必须是Car类型或者其父类
 */
public class Demo04 {
    public static void main(String[] args) {
        ArrayList<BenCi> benCis = new ArrayList<>();
        benCis.add(new BenCi());
        benCis.add(new BenCi());
        benCis.add(new BenCi());
        go(benCis);

        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);
    }
    public static void go(ArrayList<? extends Car> arrayList){

    }
}
class Car{

}
class BMW extends Car{

}
class BenCi extends Car{

}