06.java集合

最新推荐文章于 2025-03-28 19:16:53 发布
最新推荐文章于 2025-03-28 19:16:53 发布
阅读量1.1k 收藏 24
点赞数 8
文章标签： windows java 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71369720/article/details/140733178
版权

1.集合框架体系

集合主要分为两组：单列集合(collection)，双列集合(map)

单列集合(collection接口)

双列集合(map接口) 

2.Collection接口

(1).常见的方法

 */
public class arraylist_ {
    public static void main(String[] args) {
        //常用方法，用arrayList类演示
        ArrayList<String> fruits = new ArrayList<>();
        //1.add 添加单个元素
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add(1,"橘子");//在指定位置插入，香蕉后面

        //2.remove删除指定元素,可以是内容，可以是下标,并返回该元素
        fruits.remove("苹果");
        fruits.remove(0);

        //3.contains查找元素是否存在
        fruits.contains("梨");

        //4) size:获取元素个数
        System.out.println(fruits.size());

        //5)isEmpty:判断是否为空
        System.out.println(fruits.isEmpty());

        //6)clear:清空
        fruits.clear();

        //7)addAll:添加多个元素
        ArrayList<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        fruits.addAll(list);
        fruits.addAll(2,list);//在3后面加入list里的所有元素

        //8)containsAll:查找多个元素是否都存在
        System.out.println(fruits.containsAll(list));//true

        //9)removeAll: 删除多个元素
        fruits.removeAll(list);

        //10.get(index)获取指定位置的元素
        System.out.println(fruits.get(1));

        //11.indexOf()返回元素在集合首次出现的位置
        System.out.println(fruits.indexOf("1"));

        //12.LastindexOf()返回元素在集合最后次出现的位置

        //13.set(index,object)将指定位置的元素替换为obj，可以是单个元素，可以是集合
        System.out.println(fruits.set(1,"a"));

        //14.subList(formIndex,toIndex)返回从开始索引到结束索引的子集合[)

    }
}

(2).collection接口遍历元素的方法

1).使用iterator(迭代器)

  1. Iterator对象称为迭代器，主要用于遍历 Collection 集合中的元素。
  2. 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器。
  3. Iterator 仅用于遍历集合，lterator 本身并不存放对象。
  4. 在调用iterator.next（）方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。
  5. 如果希望再次遍历，需要重置迭代器iterator=list.iterator()
public class b {
    public static void main(String[] args) {
        ArrayList<String> fruits = new ArrayList<>();
        // 添加元素
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");

        // 使用迭代器遍历集合,while(itertor)快捷键itit
        //查看所有快捷键ctrl+g
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
        //第二次遍历，重置迭代器
        iterator=fruits.iterator();
        while (iterator.hasNext()) {
            String frult2 =  iterator.next();
            System.out.println(frult2);

        }

    }

}

2).增强for

  1. 增强for是简化版的iterator
  2. 只能用于遍历集合和数组 
public class c {
    public static void main(String[] args) {
        ArrayList<String> fruits = new ArrayList<>();
        // 添加元素
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");

        // 使用增强的 for-each 循环遍历集合
        //快捷键I
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

3).普通for循环 

public class f {
        public static void main(String[] args) {
            ArrayList<Integer> fruits = new ArrayList<>();
            // 添加元素
            fruits.add(1);
            fruits.add(2);
            fruits.add(3);

            // 使用增强的 for-each 循环遍历集合
            //快捷键I
            for (int i = 0; i < fruits.size(); i++) {
                int j = fruits.get(i);
                //如果添加的是String类型的，get()返回的是Integer
                System.out.println(j);
            }
            System.out.println(fruits.get(1));
        }
}

3.List

(1).ArrayList

   1).注意事项：

  1. 可以放任何值，包括null
  2. ArrayList 基本等同于Vector，除了 ArrayList是线程不安全(执行效率高) 看源码在多线程情况下，不建议使用ArrayList

   2).ArrsyList底层结构分析：

transient：表示该属性不会被序列化

(2).Vector

  1).定义说明：

  1. Vector底层也是一个对象数组，protected Object[ ] elementData;
  2. Vector 是线程同步的，即线程安全,Vector类的操作方法带有synchronized
  3. 在开发中，需要线程同步安全时，考虑使用Vector

  2).扩容机制

 (3).LinkedList

  1).定义说明

  2). 底层结构

(4).ArrayList和LinkedList比较

 

4.Set

(1).常用方法

和list接口一样，Set也是Collection的子接口，因此，常用方法和Collection一样

注：虽然Set的顺序不是存放顺序，但是这个顺序是固定的。

(2).Set接口遍历方式

迭代器、增强for、不能使用普通for(索引的方式来获取)

public class HashSet {
    public static void main(String[] args) {
        Set set = (Set) new HashSet();
        set.add("a");
        set.add("b");
        set.add("b");
        set.add(null);
        set.add(null);//不重复
        //方式一：迭代iterator
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }

        //方式二：
        for (Object o :set) {
            System.out.println(o);
        }

        //不能使用普通for循环
    }
}

(3).HashSet 

 1).定义说明：

1)HashSet实现了Set接口
2)HashSet实际上是HashMap。HashMap的底层是(数组+链表+红黑树).
3)可以存放null值，但是只能有一个null
4)HashSet不保证存放元素的顺序和取出顺序一致。

2).HashSet添加元素底层源码:

public class a {
    public static void main(String[] args) {
        Set hashSet =(Set) new HashSet();
        System.out.println(hashSet.add(new Dog("小黑")));//t
        System.out.println(hashSet.add(new Dog("小黑")));//t

        System.out.println(hashSet.add(new String("小黑")));//t
        System.out.println(hashSet.add(new String("小黑")));//F,添加不进去，看底层源码
        
    }
}
class Dog{
    private String name;

    public Dog(String name) {
        this.name = name;
    }
}

分析：

equals()方法和hash()方法同时出现。快捷键选择

 

HashSet扩容机制：

(4).LinkedHashSet

定义说明：

1)LinkedHashSet 是 HashSet 的子类。
2)LinkedHashSet 底层是一个 LinkedHashMap，底层维护了一个 数组+双向链表
3) LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
4)LinkedHashSet 不允许添重复元素

(5).treeset

treeset的底层就是treeMap

public class a {
    public static void main(String[] args) {
        //1.不做任何处理，创建TreeSet时,是无序的
        //2.现在让它按照字符串大小排序
        //3.使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
        //并指定排序规则
        TreeSet<Object> treeSet = new TreeSet<>(new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照首字母大小
                return ((String)o1).compareTo((String) o2);
                //调用字符串的compareto方法，比较字符大小
                //前-后，然后返回
                //这种添加一个a，可以成功添加

                //按照长度大小排序
                //return ( (String)o2).length() - ( (String)o1).length();
                //这个时候再添加一个长度为1的，添加失败，已经有一个长度为1的了
            }
        });
        treeSet.add("aaaa");
        treeSet.add("taa");
        treeSet.add("ka");
        treeSet.add("l");
        treeSet.add("a");

        System.out.println(treeSet);

        //1.构造器把传入的比较器对象赋给了，TreeeSet的底层的reeMap的属性this.comparator
        //2.在调用add方法时,底层会动态绑定到我们的匿名类对象compare
    }
}

5.Map接口(双列)

(1).map接口的特点：

synchronized

//1.k-v 最后是 HashMapSNode node = newNode(hash，key，value，null)
//2.K-v 为了方便程序员的遍历，还会 创建 EntrySet 集合 ，该集合存放的元素的类型 Entry，而一个Entry对象就有k，v EntrySet<Entry<K,V>>,只是指向k和v。

(2).常用方法


1)put:添加，如果key一样，value不一样，会发生替换
2)remove:根据键删除映射关系
3) get: 根据键获取值
4)size:获取元素个数
5)isEmpty:判断个数是否为0
6)clear:清除
7)containsKey:查找键是否存在

(3).Map集合遍历的6种方法

public class a {
    public static void main(String[] args) {
        HashMap<Object, Object> map = new HashMap<>();
        map.put("1","one");
        map.put("2","two");
        map.put("3","two");
        map.put("4","two");
        map.put("5","two");

        //第一组：先取出key,通过Key取出对应的value
        //keySet集合里面存放的是key
        Set<Object> keyset = map.keySet();
        //(1)增强for
        for (Object o :keyset) {
            System.out.println(map.get(o));
        }

        //(2)迭代器
        Iterator iterator= keyset.iterator();
        //这里是keyset.iterator不是map,数据在keyset里面
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }

        //第二组:把values集合取出来
        // values集合(里面存放的是value值)
        Collection<Object> values = map.values();
        //使用3种方法取出value(增强for，iterator)
        //(1).增强for
        for (Object o :values) {
            System.out.println(o);
        }
        //(2)iterator
        Iterator<Object> iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object next =  iterator1.next();
            System.out.println(next);
        }

        //第三组:通过entrySet来获取
        Set<Map.Entry<Object, Object>> entries = map.entrySet();
        //(1).增强for
        for (Object o :entries) {
            Map.Entry m=(Map.Entry) o;//先把它转换为Map.Entry
            System.out.println(m.getKey()+""+m.getValue());
        }
//        (2).迭代器
        Iterator<Map.Entry<Object, Object>> iterator2 = entries.iterator();
        while (iterator2.hasNext()) {
            Map.Entry<Object, Object> next =  iterator2.next();
            //向下转型
            Map.Entry m=(Map.Entry) next;
            //next的类型是HashMap$Node
            System.out.println(next.getKey()+""+next.getValue());
        }

    }
}

(4).HashMap底层机制及源码剖析

table数组+链表+红黑数(长度大于64变树)

数组元素都是HashMap$Node（k-v）

(5).HashTable

基本介绍：

1)存放的元素是键值对: 即 K-V
2)hashtable的键和值都不能为null， 否则会抛出NullPointer
3)hashTable 使用方法基本上和HashMap一样
4)hashTable 是线程安全的(synchronized)，hashMap 是线程不安全的

(6).Properties

基本介绍：

public class properties_ {
    public static void main(String[] args) {
        Properties properties = new Properties();
        //1.添加，k，v不能为空
        properties.put("a",1);
        properties.put("a",2);//替换上面的
        properties.put("b",1);
        properties.put("c",3);
        //properties.put("a",null);异常
        System.out.println(properties);
        //通过k获取值
        System.out.println(properties.get("a"));//2
        //2.删除
        properties.remove("lic");
        System.out.println(properties);
        //3.修改
        properties.put("c",4);

    }
}

(7).treeMap

public class d {
    public static void main(String[] args) {
        //1.使用默认构造器Treemap是无序
        //2.现在按照字符K大小排序
        //3.构造器把传入的，compator接口的匿名内部类，传给TreeMap
        //4.调用put
        //4.1第一次添加，把k-v封装到Entry对象，放入root
        //4.2第二次添加，遍历所有的key，给当前的k找个合适位置
        //通过动态绑定，使用我们的匿名内部类来比较k(如果compater比较的是长度，再添加一个长度相等的，不能添加)
        //如果按照字符添加“a”,添加成功
        TreeMap<Object, Object> tp = new TreeMap<>(new Comparator<Object>() {//匿名内部类
            @Override
            public int compare(Object o1, Object o2) {
                //return ((String)o1).compareTo((String) o2);
                //按照长度排序
                return ((String) o2).length()-((String) o1).length();

            }
        });
        tp.put("qwq","1");
        tp.put("tom","1");
        tp.put("kisss","1");
        tp.put("siml","1");
        System.out.println(tp);
    }
}

 6.如何选择集合实现类

linkedhashmap：数组+双链表

7.collections工具类

public class a {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        //reverse(List): 反转 List 中元素的顺序
        Collections.reverse(list);
        System.out.println("元素反转"+list);

        //shuffle(List):对 List 集合元素进行随机排序
        //Collections.shuffle(list);
        //System.out.println(list);

        //sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
        //按照字符串顺序
        Collections.sort(list);

        //sort(List，Comparator): 根据指定的 Comparator 产生的顺序对 List 集合元素
        //现在按照字符串长度大小排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return ((String)o1).length()-((String)o2).length();
            }
        });
        System.out.println("按长度排序"+list);

        //swap(List，int， int): 将指定 List 集合中的 i 处元素和 j 处元素进行交换
        Collections.swap(list,0,1);
        System.out.println(list);

        //Object max(Collection):根据元素的自然顺序，返回集合的最大元素
        System.out.println(Collections.max(list));

        //Object max(Collection,Comparator):根据Comparator给的顺序，返回集合的最大元素
        //比如，返回长度最值的元素
        Collections.max(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return ((String)o1).length()-((String)o2).length();
            }
        });

        //Object min(Collection):根据元素的自然顺序，返回集合的最小元素
        //Object min(Collection,Comparator):根据Comparator给的顺序，返回集合的最小元素
        //和max一样

        //int frequency(list, src):list是集合,src是要统计的字符串
        System.out.println("a出现的次数"+Collections.frequency(list,"a"));

        //void copy (list,src):将src的内容复制到list
        //为了完成一个完整的拷贝，我们需要先给list赋值，大小和src一样
        ArrayList<String> list1 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            list1.add("");
        }
        Collections.copy(list1,list);
        System.out.println(list1);

        //boolean replaceAll(list,"a","b")把list集合里的a替换为b
        Collections.replaceAll(list,"a","A");
        
    }
}

8.练习

1.

(1).创建 3个 Dog {name,age} 对象，放入到 ArrayList 中，赋给 List 引用
(2).用选代器和增强for循环两种方式来遍历
(3).重写Dog 的toString方法，输出name和age

public class e1 {
    public static void main(String[] args) {
        List<Object> Dog = new ArrayList<>();
        Dog.add(new Dog("小白",1));
        Dog.add(new Dog("小黑",2));
        Dog.add(new Dog("小红",3));

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

        for (Object dog :Dog) {
            System.out.println(dog);
        }


    }
}
class Dog{
    private String name;
    private int age;

    public Dog(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 "姓名:"+this.name+" ,年龄:"+this.age;
    }
}

2.

public class a {
    public static void main(String[] args) {
        ArrayList<Object> book = new ArrayList<>();
        book.add(new Book("西游记", "吴承恩", 10));
        book.add(new Book("水浒传", "施耐庵", 19));
        book.add(new Book("红楼梦", "曹雪芹", 100));
        book.add(new Book("三国演", "罗贯中", 80));
        //book.add(new Book("西游记","吴承恩",10));
        int[] array = new int[book.size()];

        for (Object o : book) {
            System.out.println(o);
        }
        BubbleSort(book);
        for (Object o : book) {
            System.out.println(o);
        }

    }

    //静态方法
    public static void BubbleSort(List list) {
        // 外层循环控制冒泡排序的趟数
        // size-1表示：最后一趟区间中只剩余1个元素，该趟冒泡可以省略
        for (int i = 0; i < list.size() - 1; i++) {
            // 具体冒泡的方式：用相邻的两个元素进行比较，前一个大于后一个元素时，交换着两个数据，依次直到数组的末尾
            for (int j = 1; j < list.size() - i-1; j++) {
                //取出book
                Book book1=(Book)list.get(j);
                Book book2=(Book)list.get(j+1);
                if (book1.getPrice()>book2.getPrice()) {
                    list.set(j,book2);
                    list.set(j+1,book1);
                }
            }
        }

    }
}
class Book{
    private String name;
    private int price;
    private String actor;

    public Book(String name, String actor,int price) {
        this.name = name;
        this.price = price;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

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

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    @Override
    public String toString() {
        return "名称"+name+"\t\t价格:"+price+"\t\t作者:"+actor;
    }
}

3.

 

ublic class e3 {
    public static void main(String[] args) {
        HashSet<Object> set = new HashSet<>();
        set.add(new Employee1("a",12));
        set.add(new Employee1("b",19));
        set.add(new Employee1("a",12));
        System.out.println(set);

    }
}
class Employee1 {
    private String name;
    private int age;
    //如果name'和age相同，返回相同的


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

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

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

4.

public class e1 {
    public static void main(String[] args) {
        Set set = (Set) new HashSet();

        set.add(new Employee("1", 1000, new MyDate(2,2,2)) );
        set.add(new Employee("1", 1000, new MyDate(2,2,2) ));
        set.add(new Employee("2", 1000, new MyDate(2,2,2) ));
        System.out.println(set.toString());

    }
}
class Employee{
    private String name;
    private int sal;
    private MyDate birthday;

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

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

    public Employee(String name, int sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}
 class MyDate{
    private int year;
    private int month;
    private int day;

     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         MyDate myDate = (MyDate) o;
         return year == myDate.year && month == myDate.month && day == myDate.day;
     }

     @Override
     public int hashCode() {
         return Objects.hash(year, month, day);
     }

     public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

     public int getYear() {
         return year;
     }

     public void setYear(int year) {
         this.year = year;
     }

     public int getMonth() {
         return month;
     }

     public void setMonth(int month) {
         this.month = month;
     }

     public int getDay() {
         return day;
     }

     public void setDay(int day) {
         this.day = day;
     }

     @Override
     public String toString() {
         return "MyDate{" +
                 "year=" + year +
                 ", month=" + month +
                 ", day=" + day +
                 '}';
     }
 }

5.

public class e4 {
    public static void main(String[] args) {
        LinkedHashSet<Object> set = new LinkedHashSet<>();
        set.add(new Car("qwq",123));
        set.add(new Car("qwq",123));
        set.add(new Car("奔驰",12223));
        System.out.println(set);


    }
}
class Car{
    private String name;
    private double price;

    public Car(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(price, car.price) == 0 && Objects.equals(name, car.name);
    }

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

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

5.

键:员工id
值:工对象
使用HashMap添加3个员工对象，要求
并遍历显示工资>18000的员工(遍历方式最少两种)
员工类: 姓名、工资、员工id

public class e5 {
    public static void main(String[] args) {
        HashMap<Object, Object> map = new HashMap<>();
        map.put("123456",new Emplyee("小明",12000,"123456"));
        map.put("123457",new Emplyee("小来",19000,"123457"));
        map.put("123458",new Emplyee("小张",1200,"123458"));
        Set<Object> objects = map.keySet();
        for (Object o :objects) {
            //先获取value
            Emplyee e=(Emplyee) map.get(o);//根据键获取值,再转为emp
            if (e.getSal()>18000)
                System.out.println(e);
        }
        //1.先获取entrySet
        Set<Map.Entry<Object, Object>> entries = map.entrySet();
        //2.创建enterset的迭代器
        Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            //3.把迭代的内容转为Map.entry
            Map.Entry<Object, Object> next = (Map.Entry) iterator.next();
            //4.Map.entry通过getValue获取内容,再把内容转为Emplyee
            Emplyee e1=(Emplyee) next.getValue();
            if (e1.getSal()>18000)
                System.out.println(e1);
        }
        


    }
}
class Emplyee{
    private String name;
    private int sal;
    private String id;

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

    public String getName() {
        return name;
    }

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

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

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

 6.

按要求实现:
(1)封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象
时只打印标题;
(2) 只提供一个带参数的构造器，实例化对象时，只初始化标题; 并且实例化两个对象:
新闻一: 新冠确诊病例超千万，数百万印度教信徒赴恒河“圣浴”引民众担忧
新闻二:男子突然想起2个月前钓的鱼还在网兜里，捞起一看赶紧放生
(3)将新闻对象添加到ArrayList集合中，并且进行倒序遍历;
(4)在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前15个，然后在后边加
(5) 在控制台打印遍历出经过处理的新闻标题

public class e1 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList<>();
        list.add(new News("新闻一:新冠确诊qwqwq，并且实例化两个对象qwqwqq"));
        list.add(new News("新闻二:突然想起来2个月前的鱼还在与哇嘎里aaaaaa"));
        Collections.reverse(list);
        for (Object o :list) {
            News n=(News) o;
            System.out.println(processTitle(n.getTitle()));
        }

    }
    public static String processTitle(String title) {
        if (title==null){
            return "";
        }
        if(title.length()>15){
            return title.substring(0,15)+"...";//(0,15]
        }else {
            return title;
        }
    }
}

class News{
    private String title;
    private String content;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "News{" +
                "title='" + title  +
                '}';
    }

    public News(String title) {
        this.title = title;
    }
}

7.

按要求完成下列任务
1)使用HashMap类实例化一个Map类型的对象m，键 (String) 和值 (int)分别用于存储员
工的姓名和工资，存入数据如下：jack-650元; tom-1200元; smith-2900元;
2)将iack的工资更改为2600元，为所有员工工资加薪100元;
3)遍历集合中所有的员工
4)遍历集合中所有的工资

public class e3 {
    public static void main(String[] args) {
        HashMap<Object, Object> map = new HashMap<>();
        map.put("jack",650);
        map.put("tom",1200);
        map.put("smith",2900);
        map.replace("jack",2600);

        //薪资加100
        Set keyset=map.keySet();
        for (Object o :keyset) {
            map.put(o,(Integer)map.get(o)+100);
        }
        System.out.println(map);

        //遍历
        Set<Map.Entry<Object, Object>> entries = map.entrySet();
        Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<Object, Object> next =  iterator.next();
            System.out.println(next.getKey()+"="+next.getValue());
        }
        
        //遍历工资
        Collection<Object> values = map.values();
        for (Object o :values) {
            System.out.println(o);

        }


    }
}

8.

试分析HashSet和TreeSet分别如何实现去重的？
(1)HashSet的去重机制:

  1.  hashCode()+ equals(),底层先通过存入对象,进行运算得到一个hash值，
  2. 通过hash值得到对应的索引，
  3. 如果发现table索引所在的位置,没有数据，就直接存放
  4. 如果有数据，就进行equals比较[遍历比较]，
  5. 如果比较后，不相同,就加入，否则就不加入.

(2) TreeSet的去重机制:

  1. 如果你传入了一个Comparator匿名对象，就使用实现的compare去重。
  2. 如果方法返回0,就认为是相同的元素/数据，就不添加。
  3. 如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Compareable接口的compareTo去重。(字符串的compaterto方法比较的是内容)

9.

6.java集合框架.zip
06-15
6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6.java集合框架.zip6....
5.java集合概述.zip
06-15
5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5.java集合概述.zip5....
Java集合特点
m0_68206534的博客
03-26 4395
1、基本语法 这包括static、final、rtransient等关键字的作用，foreach循环的原理等等。 2、集合 基本上就是List、Map、Set，问的是各种实现类的底层原理，实现类的优缺点 List集合：有序集合，用户可以精确控制列表中每个元素的插入位置。用户也可以通过整数索引访问元素，并搜索列表中的元素。与Set集合不同，列表通常允许重复元素。 ArrayList的底层数据结构是数组 特点： 索引查询速度最快；长度可以自动动态变化 添加和删除元素效率低；按照内容查询需要逐个比
3. Java Stream 集合去重 distinct
静艺的专栏
03-08 3472
distinct（）使用hashCode（）和equals（）方法来获取不同的元素。因此，我们的类必须实现hashCode（）和equals（）方法。 如果distinct（）正在处理有序流，那么对于重复元素，将保留以遭遇顺序首先出现的元素，并且以这种方式选择不同元素是稳定的。在无序流的情况下，不同元素的选择不一定是稳定的，是可以改变的。distinct（）执行有状态的中间操作。 在有序流的并行流（parallelStream）的情况下，保持distinct（）的稳定性是需...
java集合（详解）
abc98526的博客
04-24 1万+
文章目录 什么是集合? Collection的基本使用 接口实现类 Collections工具类 Map接口及其实现类 Map是不是集合? 什么是集合? 集合是指具有某种特定性质的具体的或抽象的对象汇总而成的集体，有时集合也称之为容器，java中在util包...
Java集合的排序
qq_41159942的博客
07-13 2796
1. Java中集合的排序方法 当需要进行排序的数据存放在实现了集合Collection接口的类Map，set，list等这些中时，可以使用Collection实现的sort方法对数据进行排序，sort方法主要有以下两种： public static <T extends Comparable<? super T>> void sort(List list) public static void sort(List list, Comparator<? super T&gt
java集合（超详细）
Catastrophe的博客
04-30 2482
hi，我是，一个资深Java开发工程师，平时十分热衷于技术副业变现和各种搞钱项目的程序员~，如果你也是，可以一起交流交流。今天我们来聊聊Java集合~
成功解决java.lang.OutOfMemoryError: Java heap space错误
小明的Java问道之路
01-03 12万+
这个错误会在JVM（Java Virtual Machine，Java虚拟机）的堆内存空间不足以满足程序新对象实例创建需求时产生。简单说，它就表示我们的程序已经消耗尽了所有可用的堆内存。
java集合详解
m0_74890428的博客
11-10 2928
本文主要介绍了集合类体系结构，主要包括Collection概述和使用，List集合的概述和使用，Set集合的概述和使用和Map集合的概述和使用。并且用代码实现了关键的步骤，详细地介绍类各种集合的遍历方法。
Java常用集合区别
weixin_38589993的博客
04-04 2044
一、集合与数组的区别 相同点： 都是用来存储数据的。 不同点： 1.集合带array的，底层由数组实现，还有一部分由其他方式(树、链表等)实现。 2.数组大小固定，而集合没有固定的大小，更方便存储。 3.数组只能放一种类型，集合不考虑泛型可以存多种类型。 4.集合放基本类型是通过装箱拆箱(包装类与基本数据类型的转换)来实现的。（写泛形的时候不能用int，而要用Integer） 二、几种常用集合之间的关系 Map接口自成一系，是以键值对(Key,Value)方式存储数据的，属于双列集合。 Set接口的实现类：
Java集合汇总篇
热门推荐
12-13 22万+
一. 集合框架 Java 集合框架一些列的接口和类来实现很多常见的数据结构和算法，例如 LinkedList 就是集合框架提供的实现了双向链表的数据结构，关于这一篇文章建议大家收藏，我会不断地完善和扩充它的内容，例如最下面的系列文章我以后也会对它进行不断的更新 集合框架的接口 集合框架提供了很多接口，这些接口都包含了特定的方法来实现对集合上的特定操作 ) 我们将要学习这些接口以及子接口和它们的各种实现类，在开始之前我们先简单学习一下这些广泛运用的接口，可以看到整个集合框架，总共有三个顶级接口Collecti
Java集合去重
qq_41053971的博客
04-21 7497
在日常工作中，我们时常会遇到需要对数据进行遍历去重的操作，笔者便将自己所熟知的几种方法分享给大家。 首先模拟一个实体类，并创建一个main方法调用。 public static void main(String[] args) { List<User> list = new ArrayList(4); list.add(new User("张三","杭州")); list.add(new User("李四","上海")); .
14.java集合转换（了解）.zip
06-15
14.java集合转换（了解）.zip14.java集合转换（了解）.zip14.java集合转换（了解）.zip14.java集合转换（了解）.zip14.java集合转换（了解）.zip14.java集合转换（了解）.zip14.java集合转换（了解）.zip14.java集合...
15.java集合工具类（了解）后期扩展.zip
06-15
15.java集合工具类（了解）后期扩展.zip15.java集合工具类（了解）后期扩展.zip15.java集合工具类（了解）后期扩展.zip15.java集合工具类（了解）后期扩展.zip15.java集合工具类（了解）后期扩展.zip15.java集合工具...
Java基础篇：Java集合.pdf
04-24
该文档主要详细总结了Java集合的相关知识，包括Collection和Map接口、Collection接口的子接口List和Set接口以及具体的实现类、存储原理等；Map接口的子接口HashMap、LinkedHashMap、TreeMap、Properties等
H3CNE技术考核
m0_64505752的博客
03-27 775
5.SW3作为DHCP服务器，配置两个地址池，分别为192.168.1.0/24网段和192.168.2.0/24网段网关分别为192.168.1.254和192.168.2.254，dns统一为114.114.114.114；4.SW1和SW2属于二层交换机，SW3为三层交换机（VLAN100用于对接R4）,在交换机之间相连的链路放行相关VLAN（不允许放行所有VLAN）6.在R4上配置静态路由，使其有到达各个部门的路由，在R3上配置默认路由，使其全网互通。1.按照图示配置IP地址。
CMake 简单使用总结
最新发布
LiggerBill的博客
03-28 854
CMake 是一个跨平台的构建系统生成工具，用于管理项目的编译、链接和打包流程。通过文件描述项目的源文件依赖关系和编译选项。
FreeRTOS学习（十一）：列表和列表项详解（一篇讲懂！简单易懂！）
m0_71304252的博客
03-27 1464
FreeRTOS中的列表是一个重要的数据结构，它在概念上类似于链表。它是一个双向环形链表列表项之间的地址是非连续的，是通过指针人为连接到一起的列表项的数目可以动态改变，随时可以添加或删除非常适合管理OS中数量不确定且状态会发生改变的任务
naiveui 封装的 图片上传组件
weixin_42759398的博客
03-28 321
naiveui 的图片上传 原生写法非常繁琐，而且 不能自动拆分url,在多图上传的时候 很麻烦，所以我封装了一个上传图片的组件，分享给naive 使用者。只要是 绑定这个 formValue.idCardPhoto 你所需要的 字段 就行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值