javaSE-13-List集合1

最新推荐文章于 2024-06-20 19:01:05 发布

___信仰°冷暖自知丶

最新推荐文章于 2024-06-20 19:01:05 发布

阅读量196

点赞数

分类专栏： API 文章标签： java

本文链接：https://blog.csdn.net/weixin_36580930/article/details/115496394

版权

API 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

数组转List相关操作及数组的工具类Arrays

Collections集合的工具类之排序

集合提供的forEarch遍历

线程不安全的集合

Collections集合的工具类之将不安全的集合转换为线程安全的集合

List接口

List接口继承自Collection接口

List两个常用实现类

java.util.ArrayList；
java.util.LinkedList；

list的相关方法

E get（int index）；获取
支持for循环遍历；
E set（int index,E e）;替换

Collections集合的工具类之反转

void reverse（List<?> list）

/**
 * java.util.List接口
 * List继承自Collection.List集合，是可重复集，并且有序，提供了一套可以通过下表操作元素的方法
 * 常用实现类：
 * java.util.ArrayList:内部使用数组实现，查询性能更好。增删性能一般
 * java.util.LinkedList:内部使用链表实现，收尾增删元素性能更好 ，链表会记着首尾，所以首尾增删性能要求
 * 苛刻的时候用linkedLIst
 *
 * 业务上一般用ArrayList就够用了，如果有首尾增删要求 就用LinkedList
 */
public class Demo5 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        System.out.println(list);
        /**
         * list 集合专有的方法
         */

        /*
            E get(int index);
            获取当前List集合中指定下标处对应的元素
         */
        String str = list.get(2);
        System.out.println(str);

        /*
            for循环遍历
         */
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }

        /*
            E set(int index,E e)
            将给定元素设置到指定位置上，返回值为该位置原来对应的元素
            替换操作
         */
        //one ,six,three,four
        String old = list.set(1,"six");
        System.out.println(list); //[one, six, three, four]
        System.out.println("被替换的元素是："+old);//被替换的元素是：two


        /*
            将集合反转
            在不创建新集合的情况下 用get set方法
            不除以2的话，到中间以后，又换回来了
         */
        for(int i=0;i<list.size()/2;i++){
            String s = list.get(list.size()-i-1);
            String s1 = list.set(i,s);
            list.set(list.size()-i-1,s1);
        }
        System.out.println(list);//[four, three, six, one]


        /*
            java.util.Collections是集合的工具类，里面提供了很多静态方法，可以方便操作集合
            反转
         */
        Collections.reverse(list);
        System.out.println(list);//[one, six, three, four]
    }
}

list集合提供的重载方法

void add（int index,E e）
E remove（int index）

 public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        System.out.println(list);

        /*
            void add(int index,E e);
            将给定元素插入到指定位置
         */
        list.add(2,"six");
        System.out.println(list);//[one, two, six, three, four, five]

        /*
            E remove(int inde)
            删除并返回给定位置上的元素
         */
        String old = list.remove(3);
        System.out.println(list);//[one, two, six, four, five]
        System.out.println(old);//three
    }

List集合支持获取子集的操作

List subList（int start，int end）

/**
 * List集合支持获取子集操作
 * List subList（int start，int end）
 * 获取当前集合中指定范围内的子集，两个数字表示下标范围，含头不含尾
 */
public class Demo7 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i);
        }

        list.subList(3,7);//这里没有赋新值，所以没用
        System.out.println(list);//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        List<Integer> subList = list.subList(3,7);
        System.out.println(subList);//[3, 4, 5, 6]


        /*
            将子集元素扩大10倍
            [30,40,50,60]
            对子集的操作就是对原集合的操作
         */
        for(int i=0;i<subList.size();i++){
            subList.set(i, subList.get(i) * 10);
        }
        System.out.println(subList);//[30, 40, 50, 60]
        System.out.println(list);//[0, 1, 2, 30, 40, 50, 60, 7, 8, 9]

        /*
             对子集的操作就是对原集合对应元素的操作
            删除集合中的 2-6
         */
        list.subList(2,6).clear();
        System.out.println(list);//[0, 1, 60, 7, 8, 9]
    }
}

集合转为数组

Collection方法提供的：toArray

/**
 * 集合转换为数组
 * Collection提供了一个方法：toArray，可以将当前集合转换为一个数组
 */
public class Demo8 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        System.out.println(c);//[one, two, three, four]
        Object[] objects = c.toArray();//这里返回的是Object类型，
        //String[] strings = c.toArray();//编译错误，虽然集合我们指定了泛型，但是这里依然要强转，因为他返回的是Object类型
        System.out.println(Arrays.toString(objects));//[one, two, three, four]

        
            重载的该toArray方法，要求传入一个数组。方法内部会将给定元素存入该数组并将其返回。
            如果给定的数组长度小于集合的size，则该方法会根据给定的数组类型自行创建一个与
            集合size一致的数组，并将元素存入后返回
         
        //重载方法  长度一般我们就写集合的长度
        String[] array =c.toArray(new String[c.size()]);//注意，这里的参数长度，大、小、等都不报错，小了的话，就不用你了，用它自己的，大了的话，后面补null
        System.out.println(Arrays.toString(array));//[one, two, three, four]
        System.out.println(array.length);//4

        String[] array1 =c.toArray(new String[1]);
        System.out.println(Arrays.toString(array1));//[one, two, three, four]
        System.out.println(array1.length);//4

        String[] array2 =c.toArray(new String[10]);
        System.out.println(Arrays.toString(array2));//[one, two, three, four, null, null, null, null, null, null]
        System.out.println(array2.length);//10
    }

数组转List相关操作及数组的工具类Arrays

Arrays工具类
- 输出数组Arrays.toString（arr）；
- 数组排序Arrays.sort（arr）；
- 数组转换为List集合，Arrays.asList（arr）；
集合重载带集合参数构造方法：创建当前集合的同时包含给定集合中的所有元素

/**
 * 数组转换为List集合（数组只能转换为List集合）
 * 数组的工具类Arrays提供了一个静态方法asList，可以将一个数组转换为一个List
 */
public class Demo9 {
    public static void main(String[] args) {
        String[] array = {"one","two","thress","four"};
        List<String> list = Arrays.asList(array);
        System.out.println(list);//[one, two, thress, four]

        
            注意：
            1、当我们用asList操作后，对集合的set操作就是对数组的操作
            2、通过数组转换的集合，不能增删，操作不被允许，
                因为数组是定长的，所以集合会改变元素个数的操作都不支持
                运行错误 java.lang.UnsupportedOperationException  不支持操作异常
            3、所以我要增删的话，可以子集创建一个新集合，然后把他包含进来
        
        //修改集合现有元素
        list.set(1,"sex");
        System.out.println(list);//[one, sex, thress, four]
        System.out.println(Arrays.toString(array));//[one, sex, thress, four]

        //list.add("asdf"); 运行错误 java.lang.UnsupportedOperationException  不支持操作异常

        
            1、若希望对元素进行增删操作，则需要自行在创建一个集合，并包含数组转换的集合中的所有元素即可
            2、所有集合  都支持 一个参数为 Collection(集合)类型 的 构造方法，该构造方法的作用是创建
            当前集合的同时包含给定集合中的所有元素

         
       
             注意，如果返回set集合的话，可能会丢元素，因为set大部分是不重复的
             String[] array = {"one","one","thress","four"};
                ...
             Set<String> list2 = new HashSet<>(list); //[thress, four, one, sex, five]
        
        //创建一个ArrayList的同时，包含给定的集合list 中的所有元素
        List<String> list2 = new ArrayList<>(list);
        list2.add("five");
        System.out.println(list2);//[one, sex, thress, four, five]
    }
}

Collections集合的工具类之排序

sort（）正序
shuffle（）乱序

/**
 * Collections提供了一个静态方法sort，可以对List集合进行自然排序（从小到大）
 */
public class Demo10 {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        Random random = new Random();
        for(int i=0;i<5;i++){
            list1.add(random.nextInt(35)+1);
        }
        for(int i=0;i<2;i++){
            list2.add(random.nextInt(11)+1);
        }
        System.out.println(list1);
        System.out.println(list2);
        //顺序
        Collections.sort(list1);
        System.out.println(list1);
        //乱序
        Collections.shuffle(list1);
        System.out.println(list1);
    }
}

集合提供的forEarch遍历

/**
 * JDK8之后集合提供了一个新的方法:foreach,可以使用lambda表达式遍历集合元素。
 */
public class Demo11 {
    public static void main(String[] args) {
//        Collection<String> c = new ArrayList<>();
        List<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        /*
            集合有多少个元素，就会调用该lambda表达式多少次，而每次调用时e表示的就是其中一个元素
         */
        c.forEach(e -> System.out.println(e));
    }
}

线程不安全的集合

ArrayList
LinkedList
HashSet

Collections集合的工具类之将不安全的集合转换为线程安全的集合

synchronizedList（）
synchronizedSet（）
synchronizedCollection（）


            forEach方法出现的背景
            我们常用的集合:ArrayList,LinkedList,HashSet都不是线程安全的

            借助Collections的对应方法:synchronizedList(),synchronizedSet(),synchronizedCollection()
            将现有的集合转换为一个并发安全的集合。

            就算是一个并发安全的集合，它的add,remove等操作都有synchronized修饰，也不会与迭代器
            互斥。原因是迭代器是一个单独的对象，不是通过集合自身的方法遍历，因此无法做到迭代器的
            方法与集合的方法互斥！此时就需要自行使用同步块维护迭代器遍历与集合自身操作的互斥，来保证
            并发安全。

            JDK8之后推出的forEach方法，是集合自身的遍历方法，因此可以和集合自身的add,remove等
            操作互斥，直接保证了并发安全。

        List syncList = Collections.synchronizedList(c);
        以下三个方法是互斥的，保证多线程并发安全
        syncList.add();
        syncList.remove();
        syncList.forEach();

___信仰°冷暖自知丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
javaSE-13-List集合1

目录List接口List两个常用实现类list的相关方法Collections集合的工具类之反转list集合提供的重载方法List集合支持获取子集的操作集合转为数组数组转List相关操作及数组的工具类ArraysList接口List接口继承自Collection接口List两个常用实现类java.util.ArrayList； java.util.LinkedList；list的相关方法E get（int index）；获取支持for循环遍历；.
复制链接

扫一扫