漫漫Java学习路,第十五天

最新推荐文章于 2022-11-28 17:01:29 发布

吾辈楷模曹孟德

最新推荐文章于 2022-11-28 17:01:29 发布

阅读量123

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/Jcskson/article/details/122440371

版权

package cn.tedu.collection;

import java.util.Objects;

public class Dog {
    String name;
    double price;
    int age;

    public Dog(String name, double price, int age) {
        this.name = name;
        this.price = price;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Dog dog = (Dog) o;
        return Double.compare(dog.price, price) == 0 &&
                age == dog.age &&
                Objects.equals(name, dog.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, price, age);
    }

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

package cn.tedu.collection;

import java.util.Objects;

//本类用于测试Set集合存放自定义的引用类型对象
public class Student {
    String name;
    int id;

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

package cn.tedu.collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

//本类用于ArrayLiast的相关测试
public class TestArrayList {
    public static void main(String[] args) {
        //底层会自动帮我们创建数组来存放对象,并且数组的初始容量是10
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        System.out.println(list);//[100, 200, 300, 400]

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

        System.out.println(list.contains("100"));//false,是否包含指定元素
        System.out.println(list.get(0));//100,获取指定下标所对应的元素
        System.out.println(list.indexOf(400));
        System.out.println(list.lastIndexOf(400));
        //System.out.println(list.remove(300));//会报错
        /*上面的代码会报错:数组下标越界:index:300 size:6
        * 主要是因为list中有两个重载的remove(),如果传入的是300
        * 会直接把这个300看作是int类型的index索引,所以如果想指定元素来删除数据
        * 需要把int类型的300手动装箱成Integer类型的300元素*/
        System.out.println(list);
        System.out.println(list.remove(Integer.valueOf(300)));
        System.out.println(list.remove(2));//根据下标删除元素

        System.out.println(list.set(0,777));
        System.out.println(list.size());
        System.out.println(list);

        ArrayList list2 = new ArrayList();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        System.out.println(list2);
        list.addAll(list2);
        System.out.println(list);
        list.addAll(0,list2);
        System.out.println(list);

        list.remove(list2);
        System.out.println(list);

        list.add(1);
        System.out.println(list.containsAll(list2));

        list.retainAll(list2);//取交集,保留list中属于list2的所有元素
        System.out.println(list);

        /*测试集合的迭代
        * 1.for集合
        * 2.高效fou循环
        * 3.iterator
        * 4.listInterator*/
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }
        System.out.println("----------------------------");
        for(Integer aaa:list){
            System.out.println(aaa);
        }
        System.out.println("-----------------------------");
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("-----------------------------");
        /*ListIterator属于List接口独有的迭代器
        * Iterator<E>--父接口--hasNext() next()
        * ListIterator<E>--子接口--可以使用父接口的功能,除了父接口的功能之外
        * 还有自己特有的功能,比如逆序遍历,添加元素等,但注意,不常用
        * public interface ListIterator<E> extends Iterator<E>*/
        ListIterator<Integer> it2 = list.listIterator();
        while (it2.hasNext()){
            System.out.println(it2.next());
        }
        System.out.println("-------------------------------");
    }
}

package cn.tedu.collection;

import java.util.LinkedList;

//本类用于LinkedList的相关测试
public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("唐山藏");
        list.add("沙悟净");
        list.add("小白龙");
        System.out.println(list);

        list.addFirst("九灵元圣");
        list.addLast("鬼车");
        System.out.println(list);

        System.out.println(list.getFirst());
        System.out.println(list.getLast());

        System.out.println(list.removeFirst());
        System.out.println(list);
        System.out.println(list.removeLast());
        System.out.println(list);

        System.out.println(list.element());//获取首元素,同list.getfirst();
        /*别名:查询系统*/
        System.out.println(list.peek());//获取首元素
        System.out.println(list.peekFirst());//获取首元素
        System.out.println(list.peekLast());//获取尾元素

        /*别名:新增系统*/
        System.out.println(list.offer("铁王八"));//添加尾元素
        System.out.println(list.offerFirst("痞老板"));//添加首元素
        System.out.println(list.offerLast("蟹老板"));//添加尾元素
        System.out.println(list);

        /*别名:移除系列*/
        System.out.println(list.poll());//删除首元素
        System.out.println(list.pollFirst());//删除首元素
        System.out.println(list.pollLast());//删除尾元素
    }
}

package cn.tedu.collection;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
//本类用于测试Set
public class TestSet {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("紫霞仙子");
        set.add("至尊宝");
        set.add("牛魔王");
        set.add("蜘蛛精");
        set.add("白骨精");
        set.add("紫霞仙子");
        set.add(null);
        /*1.set集合中的元素都是没有顺序的
        * 2.set集合中的元素不能重复
        * 3.set集合可以存null值,但是最多只有一个*/
        System.out.println(set);

        System.out.println(set.contains("唐僧"));
        System.out.println(set.isEmpty());
        System.out.println(set.remove(null));
        System.out.println(set);
        System.out.println(set.size());
        System.out.println(Arrays.toString(set.toArray()));

        Set<String> set2 = new HashSet<>();
        set2.add("小兔纸");
        set2.add("大西几");
        set2.add("小脑斧");
        set2.add("小海藤");
        System.out.println(set2);
        set2.addAll(set);
        System.out.println(set);
        System.out.println(set2);
        System.out.println(set.containsAll(set2));//false
        System.out.println(set2.removeAll(set));//true
        System.out.println(set2);
        System.out.println(set2.retainAll(set));
        System.out.println(set2);

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

package cn.tedu.collection;
import java.util.HashSet;
import java.util.Set;
//本类用于测试Set存放自定义引用类型对象的去重问题
public class TestSet2 {
    public static void main(String[] args) {
        Set<Student> set = new HashSet<>();
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
        Student s4 = new Student("王五",25);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        /*如果set集合中存放的是我们自定义的类型
        * 那么需要给自定义类中添加重写的equals()与hashCode(),才会实现去重的效果
        * 不然,set集合会认为s3与s4的地址值不同,是两个不同的对象,不会去重*/
        System.out.println(set);
        System.out.println("------------------------------");
        Set<Dog> set1 = new HashSet<>();
        Dog d1 = new Dog("哈士奇",2333,5);
        Dog d2 = new Dog("边牧",3066.5,6);
        Dog d3 = new Dog("西施",10888,3);
        Dog d4 = new Dog("阿富汗猎犬",25666.8,15);
        Dog d5 = new Dog("哈士奇",2333,5);
        set1.add(d1);
        set1.add(d2);
        set1.add(d3);
        set1.add(d4);
        set1.add(d5);
        System.out.println(set1);
    }
}

package cn.tedu.map;
//本类用于简单回顾内部类
public class Demo {
    public static void main(String[] args) {
        A.Entry a = new A().new Entry();
        B.Entry b = new B().new Entry();
    }
}
class A{
    class Entry{}
}
class B{
    class Entry{}
}

package cn.tedu.map;
import java.util.*;

//本类用于测试Map接口
public class MapDemo {
    public static void main(String[] args) {
        /*Map中的数据要符合映射规则,一定注意要同时指定K和V的数据类型
        * 至于这个K和V具体要设置成什么类型,取决于具体的业务需求*/
        Map<Integer,String> map = new HashMap<>();
        map.put(9527,"白骨精");
        map.put(9528,"奔波儿灞");
        map.put(9529,"霸波尔奔");
        map.put(9530,"孔雀大明王");
        map.put(9527,"女儿国国王");
        map.put(9531,"孔雀大明王");
        /*1.Map中的key不允许重复,如果重复,后面的value会把前面的value覆盖掉
        * 比如:女儿国国王和白骨精的key都是9527,白骨精就被覆盖掉了
        * 2.Map中的value可以重复,比如我们有两个孔雀大明王*/
        System.out.println(map);
        //map.clear();//清空集合
        //System.out.println(map);//{}
        System.out.println(map.isEmpty());//false,判断集合是否为空
        System.out.println(map.size());//5,获取集合中键值对的对数
        System.out.println(map.containsKey(9527));//true,判断集合是否包含指定的键
        System.out.println(map.containsValue("白骨精"));//false,判断集合是否包含指定的值
        System.out.println(map.remove(9529));//将指定的key和value一起删除
        System.out.println(map.containsValue("霸波尔奔"));
        System.out.println(map.containsKey(9529));

        //将map中所有的value值取出,存入Collection中
        Collection<String> c = map.values();
        System.out.println(c);

        /*Map集合的迭代方式1:
        * 方式一:遍历map中的数据,但是map本身没有迭代器,所以需要先转换成set集合
        * 用到的方法:keySet():把map中的所有key中存入到set集合中Set<Key>*/
        Set<Integer> set = map.keySet();
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println("{"+key+","+value+"}");
        }
        /*方拾二:
        * 遍历map集合,需要把map集合先转成set集合
        * 是把map中的一对键值对key&value作为一个Entry<k,v>整体放入set
        * 一对k,v就是一个Entry*/
        Set<Map.Entry<Integer,String>> set2 = map.entrySet();
        Iterator<Map.Entry<Integer,String>> it2 = set2.iterator();
        while(it2.hasNext()){
            Map.Entry<Integer,String> entry = it2.next();
            System.out.println(entry);
        }

    }
}