Java之单列集合和双列集合_java双链集合怎么连单链集合一起用-CSDN博客

本文链接：https://blog.csdn.net/m0_59058407/article/details/129699406

Collection集合的遍历

迭代器

是什么?

就是集合自带的一种可以遍历集合的方式,可以使用增强for的语法简化这种方式的代码;

代码

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

public class MyIterator {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        //先获取迭代器对象(Iterator就是迭代器对象,用于遍历集合的工具)
        Iterator<String> iterator = list.iterator();
        //判断当前位置是否有元素可以获取,hasNext()返回是true,说明有元素可以获取,反之没有
        while (iterator.hasNext()) {
            //获取当前位置的元素,然后自动指向下一个元素
            String next = iterator.next();
        }
        System.out.println(list);
    }
}

增强for

是什么?

是对集合或数组遍历的一种简便方式;

格式

for(数据类型 变量名 : 集合名或者数组名){
	此时的变量名表示的就是集合中每一个元素
}

代码

public class MyFor {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        System.out.println(list);
        //使用增强for遍历集合
        for (String s : list) {
            System.out.println(s);
        }
        //使用增强for遍历数组
        String[] arr = {"迪丽热巴", "古力娜扎", "稀奇哈哈"};
        for(String name: arr){
            System.out.println(name);
        }
    }
}

forEach方法

是什么?

是Collection接口中定义的默认方法,所以所有的实现类对象,都可以直接调用;

怎么用?

所有的实现类对象,都可以直接调用;调用的时候,传递一个带一个参数,不带返回值的lambda即可,此时的这个参数表示的就是集合中的每一个元素;

代码

public class MyForEach {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        System.out.println(list);
        //使用lambda表达式对匿名内部类进行简化
        list.forEach(s -> System.out.println(s));
        //调用forEach方法
    //由于参数是一个Consumer接口，所以可以传递匿名内部类
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
    }
}

List系列的集合

是什么?

是Collection集合下的一个分支,这个分支的特点是:
1: 有序;
2: 可重复;
3: 有索引;

具体实现类

1. ArrayList  数组结构的集合,特点是: 查询快,增删慢;
2. LinkedList  链表结构的集合,特点是: 查询慢,增删快;

常用方法

凡是带索引的方法都可以使用;

public class MyList {
    public static void main(String[] args) {
        //创建一个list集合
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        //删除集合中所有的b   --->正着删 从前往后删
        for (int i = 0; i < list.size(); i++) {
            //判断是否有b,有就直接删除,没有就继续
            if (list.get(i).equals("b")) {
                list.remove(i);
                //注意!!!
                i--;
            }
        }
        //删除集合中所有的b   --->倒着删  从后往前
        for (int i = list.size() - 1; i >= 0; i--) {
            list.remove(i);
        }
        System.out.println(list);
    }
}

set系列集合

是什么?

是Collection集合的一个分支,特点是:
1: 无序;
2: 无索引;
3: 不重复;

具体实现类

1. HashSet集合; 底层是hash表结构,增删改查性能都很高,去重复数据的时候,依赖 hashCode方法和equals方法,**二者缺一不可**!
2. LinkedHashSet集合,是Hashset集合的子类,保证了添加数据和获取数据的顺序一致,其他和hashset集合一样,但是不常用;
3. TreeSet集合,底层是红黑树结构,特点是可以对里面的元素排序;

常用方法

Collection中所有不带索引的方法都可以使用;

HashSet存字符串数据练习

public class MyHashSet {
    public static void main(String[] args) {
        //创建set集合
        Set<String> set = new HashSet<>();
        //添加元素
        set.add("aa");
        set.add("dd");
        set.add("aa");
        set.add("bb");
        set.add("cc");
        set.add(new String("aa"));
        for (String s : set) {
            System.out.println(s);
        }
        System.out.println("aa".hashCode());
        System.out.println(new String("aa").hashCode());
    }
}

HashSet存手机数据练习

public class Phone {
    private String brand;
    private double price;

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

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

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

    public Phone() {
    }

    public Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("equals方法执行了...");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Phone phone = (Phone) o;

        if (Double.compare(phone.price, price) != 0) return false;
        return brand != null ? brand.equals(phone.brand) : phone.brand == null;
    }

    @Override
    public int hashCode() {
        System.out.println("hashcode方法执行了...");
        int result;
        long temp;
        result = brand != null ? brand.hashCode() : 0;
        temp = Double.doubleToLongBits(price);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
}
/*
    使用HashSet集合存手机数据
 */
public class MyHashSet2 {
    public static void main(String[] args) {
        // 1: 创建set集合
        Set<Phone> set = new HashSet<>();
        // 2: 添加元素
        Phone p1 = new Phone("小米", 999.8);
        Phone p2 = new Phone("华为", 999.8);
        Phone p3 = new Phone("小米", 999.8);
        Phone p4 = new Phone("小米", 999.8);
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);

        System.out.println(set);
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());
        System.out.println(p4.hashCode());
    }
}

TreeSet集合

是什么?

可以对里面的元素排序,但是需要我们自己指定排序规则,可以使用自然排序,也可以使用比较器,推荐使用比较器;

怎么用

使用带比较器(也可以写lambda)参数的构造方法创建集合对象;

常用方法依然参考Collection;

public class MyTreeSet {
    public static void main(String[] args) {
        // 1: 由于String类是java编写的,且写的时候,已经实现了自然排序接口,TreeSet集合可以直接排序
        TreeSet<String> set = new TreeSet<>();// 空参数的构造方法就是使用自然排序的
        set.add("b");
        set.add("b");
        set.add("a");
        set.add("d");
        set.add("c");
        System.out.println(set);
        // 想存字符串数据的时候,按字典顺序的降序排列
        //带参数的构造方法,传递一个比较器
        TreeSet<String> set2 = new TreeSet<>((s1,s2)->s2.compareTo(s1));
        set2.add("b");
        set2.add("b");
        set2.add("a");
        set2.add("d");
        set2.add("c");
        System.out.println(set2);
    }
}
运行结果:
	[a, b, c, d]
	[d, c, b, a]

TreeSet集合存自定义类型排序

/*
    使用TreeSet集合保存学生,按学生年龄升序排列
 */
public class Test03 {
    public static void main(String[] args) {
        // 1: 创建集合对象同时指定排序规则
        TreeSet<Student> set = new TreeSet<>((s1,s2)->{
            int i = s1.getAge() - s2.getAge();
            return i==0?s1.getName().compareTo(s2.getName()):i;
        });
        set.add(new Student("张三",18));
        set.add(new Student("李四",28));
        set.add(new Student("张三",18));
        set.add(new Student("王五",25));
        System.out.println(set);
    }
}

public class Student {
    private String name;
    private int age;
	...(快捷键 Alt+Insert)

集合的构造方法

/*
    练习list系列和set系列的集合的相互转换
    生成10个不重复的10--30之间的随机数;
    分析:
        利用set系列集合去重复的特点,直接给集合添加数据即可,直到长度为10为止;
 */
public class Test {
    public static void main(String[] args) {
        //创建随机数
        Random r = new Random();
        //创建set集合
        HashSet<Integer> set = new HashSet<>();
        // 循环添加数字
        while (set.size()<10){
            set.add(r.nextInt(30-10+1)+10);
        }
        System.out.println(set);
        // 把set集合转成list系列
        ArrayList<Integer> list = new ArrayList<>(set);
        System.out.println(list);

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(3);
        list2.add(3);
        list2.add(2);
        list2.add(2);
        list2.add(3);
        list2.add(1);
        // 将list2集合中的重复数据都保留1分
        HashSet<Integer> set2 = new HashSet<>(list2);
        System.out.println(set2);
    }
}

可变参数

是什么?

就是定义方法的时候,形参的数量可以变化的意思;其本质就是一个数组,所以带可变参数的方法内部,可以把可变参数当成数组使用;

怎么用

修饰符  返回值类型  方法名(数据类型... 形参名){
    此时的形参名就是一个可变参数,可以当成数组使用
}

与数组相比的优势

当方法的形参是一个数组类型的时候,调用者就必须传递一个实际数组,而方法的形参是一个可变参数的时候,调用者,可以传递0个至多个数据;

注意事项

1. 一个方法中,最多只能使用1个可变参数;
2. 可变参数必须放在参数列表的最右边;

public class Test01 {
    public static void methd(int... arr){
        //System.out.println(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void main(String[] args) {
        // 调用 method方法的时候,可以传递数量可以变化的实际参数;可以传递 0-N个实际参数
        methd();
        methd(2,5,8);
        int[] arr = {3,6,9,1,4,7};
        methd(arr);
    }
}
运行结果:
	[]
	[2, 5, 8]
	[3, 6, 9, 1, 4, 7]

集合工具类Collections

是什么

是一个专门操作集合的工具类,里面都是静态方法,可以通过类名直接调用方法;

Map

是什么?

是java写的一个接口,表示双列集合的意思;就是键值对数据,键不可以重复,但是值可以重复;

常见的实现类

HashMap

如何使用

直接利用空参数的构造方法可以创建对象;

常见方法

1.  添加数据      put(键,值);
2.  删除数据       remove(键);
3.  修改数据      put(键,值);  当键重复的时候,值就会覆盖
4.  获取数据      get(键);
5.  获取数据增强,当取不到数据的时候,给一个默认值;   getOrDefault(键,默认值);
6.  获取长度      size();

addAll() 给集合批量添加元素
shuffle() 打乱List集合中的元素顺序
sort() 对list集合中的元素进行升序排序
/*
    集合的工具类
 */
public class MyCollections {
    public static void main(String[] args) {
        // 1: 创建集合
        ArrayList<Integer> list = new ArrayList<>();
        // 2: 批量添加数据
        Collections.addAll(list,2,5,8,3,6,9,1,4,7);
        System.out.println(list);
        // 3: 随机打乱顺序
        Collections.shuffle(list);
        System.out.println(list);
        // 4: 排序
        Collections.sort(list);
        System.out.println(list);
        // 5: 降序
        Collections.sort(list,(s1,s2)->s2-s1);
        System.out.println(list);
    }
}

map遍历

根据键找值:
	1. 先利用map的keySet方法获取所有的键;
	2. 遍历所有的键,可以获取具体的每一个键;
	3. 利用map的get方法根据键找值即可;

/*
    map
   遍历方式1
 */
public class Test01 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("119房间",501);
        map.put("116房间",510);
        map.put("110房间",502);
        // 获取所有的键
        Set<String> set = map.keySet();
        for (String k : set) {
            Integer v = map.get(k);
            System.out.println(k+"===>"+v);
        }
    }
}

键值对对象:(Entry类型)
	1. 直接利用map的 entrySet方法,获取所有的键值对对象;
	2. 遍历键值对集合,可以得到每一个键值对对象;
	3. 面向每一个键值对对象,调用getKey和getValue方法即可获取对应的键和值;

/*
    map
   遍历方式2  键值对对象
 */
public class Test02 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("119房间",501);
        map.put("116房间",510);
        map.put("110房间",502);
        // 获取所有的键值对对象
        Set<Map.Entry<String,Integer>> set = map.entrySet();
        for (Map.Entry<String, Integer> entry : set) {
            // 此时的entry表示的就是每一个键值对对象
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"===>"+value);
        }
    }
}