Java篇（七）

最新推荐文章于 2024-05-16 10:23:10 发布

m0_61072809

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量40

点赞数

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

本文链接：https://blog.csdn.net/m0_61072809/article/details/128861933

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.集合类

1）队列LinkedList

LinkedList<>便于插入和删除，但是查找效率低

    @Test
    void queueOperation(){
        var queue=new LinkedList<>();
        queue.add(3);//增加,对于有限制的队列，队满时unchecked异常
        queue.offer(4);//增加，对于有限制的队列，队满时返回false
        queue.addFirst(11);//加至队头
        queue.remove();//出队并查看，空时抛出异常
        queue.poll();//出队并查看，空时返回null
        queue.removeLast();//删除队尾元素
        queue.element();//查看，空时抛出异常
        queue.peek();//查看，空时返回null
        queue.getLast();//查看队尾元素
        
    }

迭代器

通常在队的两头操作，如果要在队中操作，使用迭代器

    var it=queue.iterator(); //创建迭代器
        if(it.hasNext()){ //判断
            Integer f= it.next(); //指向第一个
            logger.info(f.toString());
        }
        it.next(); //指向下一个
        it.remove(); //删除当前指向的元素 
        for(int x: queue){ 可使用for each 遍历
            System.out.println(x);
        }

ListIterator

iterator()只能删除，不能在中间插入，通常只需要用add或offer在队尾插入，若要实现队中插入，可以使用listIterator()

        //可在中间插入元素的迭代器
        var listIt=queue.listIterator(1);//默认值为0
        listIt.add(33);//在下标1处插入33,光标自动加1
        listIt.next();
        listIt.add(44);
        System.out.println(queue.get(3));//44 . 查找效率极低
        System.out.println(queue.contains(33));//true

        listIt.next();
        listIt.remove();//删除5

        listIt.previous(); //光标前移
        listIt.set(66); //44改为66
        System.out.println(listIt.nextIndex());//后一元素的序号，3
        System.out.println(listIt.previousIndex());//前一元素的序号，2

        print(queue);

如果光标的起始位置在第一个元素前，从0开始数，使用remove删除的是光标前的元素；set修改的是光标后的元素；add添加在光标处，添加后移动至新增元素后，所以可连续使用add，但是remove不可以。

2)数组列表ArrayList

可动态分配数组，有缓存，所以便于查找指定位置的元素。

Vector类可以保证同步，但通常只有一个线程访问，ArrayList就够了。

3）散列集HashSet

一个无序集合。可以指定初始容量和填装因子，默认值为0.75，超过这个长度容量自动扩展为2倍。

4）树集TreeSet

一个有序集合。插入的比较次数不会超过树高。可以有序输出，可自定义排序方式

5)优先队列PriorityQueue

便于删除最小元素，常用于优先级队列

2.映射

有HashMap和TreeMap

如果不需要有序访问，HashMap更快。

    void MapTest(){
        var map=new HashMap<Integer,String>();
        map.put(1,"Ben");
        map.put(2,"Peter");
        map.put(3,"Alice");
        map.remove(2);
        logger.info(map.get(1));
        logger.info(map.getOrDefault(2,"null"));
        logger.info(String.valueOf(map.containsKey(3)));
        var map2 = new HashMap<Integer, String>(map);
        map2.forEach((k,v)->{
            System.out.println("k="+k+",v="+v);
                }
        );
        var keys=map.keySet();
        System.out.println(keys);
        var values=map.values();
        System.out.println(values);
    }

需要记住插入顺序，就用LinkedHashMap

3.视图

如果只作为临时变量且不需要修改，可以使用试图，减少开销。

    void view(){
        List<Integer> list=List.of(1,2,3,4);
        Set<Integer> set=Set.of(5,6);
        Map<Integer,String> map=Map.of(1,"a",2,"b");
        System.out.println(list.get(0));
        System.out.println(set.contains(5));
        System.out.println(map.get(1));

    }

4.算法

不需要为不同的集合类型设计不同的算法，要善于使用泛型，其中使用迭代器代替get和set。

善于使用Java类库的函数,设计时尽可能使用接口，使用泛型类代替具体类，使用父类代替子类，如Collection<Item>.

根据类中的成员排序

staff.sort(Comparator.comparingDouble(Employee::getSalary));

倒序排列

staff.sort(Comparator.reverseOrder());

根据成员倒序

staff.sort(Comparator.comparingDouble(Employee::salary).reversed());

集合常用方法

        Collections.shuffle(numbers);//打乱顺序
        Collections.binarySearch(list,3);//二分查找
        Collections.max(list);//最大值
        Collections.fill(list,2);//用2填充
        Collections.replaceAll(list,2,4);//所有2换为4

批操作

$A\cap B$