Java筑基27-集合选型规则&案例

程序员飞扬

已于 2022-06-12 00:01:06 修改

阅读量226

点赞数 1

分类专栏： Java筑基系列文章标签： java 开发语言

于 2022-06-11 23:59:26 首次发布

本文链接：https://blog.csdn.net/lu_xin5056/article/details/125240491

版权

Java筑基系列专栏收录该内容

36 篇文章 1 订阅

订阅专栏

一、集合选型

二、Collections工具类

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class Collections_ {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("alice");
        list.add("jack");

        System.out.println(list);

        //反转集合
        Collections.reverse(list);
        System.out.println(list);

        Collections.shuffle(list);
        System.out.println(list);

        //根据自然顺序，按照升序排列。
        Collections.sort(list);
        System.out.println(list);

        //根据指定的比较器引起的顺序对指定的列表进行排序
        Collections.sort(list, (Object o1,Object o2) -> {
            return ((String)o1).compareTo((String)o2);
        });

        System.out.println(list);

        //交换指定列表中指定位置的元素
        Collections.swap(list,0,2);
        System.out.println(list);

        //用指定的元素代替指定列表的所有元素
        //Collections.fill(list,"aaa");
        System.out.println(list);

        //将所有元素从一个列表复制到另一个列表中
        List list2 = new ArrayList(list);//这里应该将list传给ArrayList的构造函数
        //List list3 = new ArrayList(10);//注意：这里会报错，容积不等于大小，只是分配内存

        Collections.copy(list2,list);
        System.out.println(list2);

        //根据其元素的自然顺序返回给定集合的最小元素
        Comparable min = Collections.min(list);
        System.out.println(min);

        //根据指定的比较器引发的顺序返回给定集合的最小元素
        Object min1 = Collections.min(list, (Object o1, Object o2) -> {
            return ((String) o2).compareTo((String) o1);
        });
        System.out.println(min1);

        //max 类似

        //将列表中一个指定值的所有出现替换为另一个
        Collections.replaceAll(list,"jack","aaa");
        System.out.println(list);

        //返回由指定列表支持的同步（线程安全）列表
        List list1 = Collections.synchronizedList(list);
        synchronized (list) {
            Iterator i = list.iterator(); // Must be in synchronized block
            while (i.hasNext())
                System.out.print(i.next());
        }
        System.out.println(list1);

        //Set,Map类似


        //返回一个只包含指定对象的不可变集
        Set<List> singleton = Collections.singleton(list);
        System.out.println(singleton);

        //返回一个只包含指定对象的不可变列表
        List<List> lists = Collections.singletonList(list);
        System.out.println(lists);

        //返回指定集合中与指定对象相等的元素数
        int num = Collections.frequency(list, "alice");
        System.out.println(num);


        //将所有指定的元素添加到指定的集合
        ArrayList arrayList = new ArrayList();
        arrayList.add("yyy");
        Collections.addAll(list,arrayList);
        System.out.println(list);


    }
}

三、集合案例

1.字符串截取遍历

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class HomeWork01 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new News("唐山九名男子深夜某烧烤摊搭讪不成殴打女子，望法律严惩"));
        list.add(new News("新冠病例确认超千万，数百万漂亮国民众走上街头游行示威活动继续进行"));

        for (int i = list.size()-1; i >= 0  ; i--) {
            System.out.println(processNews((News)list.get(i)).getTitle());
        }
    }

    public static News processNews(News news){
        String title = news.getTitle();
        if(title.length() > 15){
            news.setTitle(news.getTitle().substring(0,15) + "...");
            return news;
        }else{
            return news;
        }

    }
}

class News{
    private String title;
    private String content;

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

    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 + '\'' +
                '}';
    }
}

输出：

新冠病例确认超千万，数百万漂亮...

唐山九名男子深夜某烧烤摊搭讪不...

2.list操作

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

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class HomeWork02 {
    public static void main(String[] args) {
        /**
         * 使用ArrayList完成对 Car {name, price}的各种操作
         * 1. add:添加单个元素
         * 2・remove:删除指定元素
         * 3・contains 查找元素是否存在
         * 4・size:获取元素个数
         * 5・isEmpty：判断是否为空
         * 6・clear:清空
         * Car car = new Car（”宝马'，400000）;
         * Car car2 = new Car（”孰”，5000000）;
         * 7.addAll: 添加多个元素
         * 8・containsAll:查找多个元素是否都存在
         * 9.removeAll:删除多个元素
         * 使用增强for和迭代器来遍历所有的car,需要重写Car的toString方法
         */

        ArrayList list = new ArrayList();
        Car car = new Car("宝马", 400000.98);
        Car car2 = new Car("奔驰",500000.68);
        list.add(car);
        list.add(car2);
        System.out.println(list);

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

        boolean contains = list.contains(car2);
        System.out.println(contains);

        int size = list.size();
        System.out.println(size);

        boolean empty = list.isEmpty();
        System.out.println(empty);

        list.clear();
        System.out.println(list);

        ArrayList list2 = new ArrayList();
        Car car3 = new Car("路虎", 400000.98);
        Car car4 = new Car("宾利",500000.68);
        list2.add(car3);
        list2.add(car4);
        list.addAll(list2);
        System.out.println(list);

        boolean b = list.containsAll(list2);
        System.out.println(b);

        //list.removeAll(list2);
        System.out.println("list" + list);

        
        for (Object o : list) {
            System.out.print(o.toString());
        }

        System.out.println("-----");
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }
}

class Car{
    private String sign;
    private double price;

    public Car(String sign, double price) {
        this.sign = sign;
        this.price = price;
    }

    public String getSign() {
        return sign;
    }

    public void setSign(String sign) {
        this.sign = sign;
    }

    public double getPrice() {
        return price;
    }

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

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

输出：

[Car{sign='宝马', price=400000.98}, Car{sign='奔驰', price=500000.68}]

[Car{sign='奔驰', price=500000.68}]

true

false

[]

[Car{sign='路虎', price=400000.98}, Car{sign='宾利', price=500000.68}]

true

list[Car{sign='路虎', price=400000.98}, Car{sign='宾利', price=500000.68}]

Car{sign='路虎', price=400000.98}Car{sign='宾利', price=500000.68}-----

Car{sign='路虎', price=400000.98}

Car{sign='宾利', price=500000.68}

3.map操作

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class HomeWork03 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("jack",650);
        map.put("tom",1200);
        map.put("smith",2000);
        System.out.println(map);

        //修改
        map.put("jack",2000);
        System.out.println(map);

        //更新，所有人工资加200
        Set set = map.keySet();
        for (Object key : set) {
            map.put(key,(Integer)map.get(key) + 200);
        }
        System.out.println(map);

        //遍历员工
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry entry = (Map.Entry)iterator.next();
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }

        //遍历所有工资
        Collection values = map.values();
        for (Object value : values) {
            System.out.println(value);
        }
    }
}

输出：{tom=1200, smith=2000, jack=650}

{tom=1200, smith=2000, jack=2000}

{tom=1400, smith=2200, jack=2200}

tom-1400

smith-2200

jack-2200

1400

2200