2012年认证杯SPSSPRO杯数学建模A题(第二阶段)蜘蛛网全过程文档及程序

目录

• 前言
• 一、常用List
• • 1.1 List
  • • 1.1.1 特点
    • 1.1.2 常用API
  • 1.2 ArrayList
  • • 1.2.1 特点
    • 1.2.2 使用
  • 1.3 LinkedList
  • • 1.3.1 特点
    • 1.3.2 使用
  • 1.4 CopyOnWriteArrayList
  • • 1.4.1 特点
    • 1.4.2 使用
  • 1.5 Arrays.asList()
  • • 1.5.1 特点
    • 1.5.2 使用
• 二、对比总结

前言

一、常用List

1.1 List

List是Java集合框架中的接口，表示有序的集合，可以包含重复元素。

public interface List<E> extends Collection<E> {

1.1.1 特点

特点：允许元素重复，有序集合，可以通过索引访问元素。

1.1.2 常用API

1.2 ArrayList

ArrayList是基于数组实现的动态数组。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

1.2.1 特点

ArrayList的特点：支持随机访问元素，插入和删除元素效率较低。

1.2.2 使用

 public static void test1() {
        //使用ArrayList类创建列表
        List<Integer> numbers = new ArrayList<>();

        //将元素添加到列表
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("List: " + numbers);

        //从列表中访问元素
        int number = numbers.get(2);
        System.out.println("访问元素: " + number);

        //从列表中删除元素
        int removedNumber = numbers.remove(1);
        System.out.println("删除元素: " + removedNumber);
    }

输出：

1.3 LinkedList

LinkedList是基于双向链表实现的列表。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

1.3.1 特点

特点：适合插入和删除元素，但随机访问元素效率较低。

LinkedList与ArrayList的区别：
LinkedList和ArrayList都实现Collections框架的List接口。 但是，它们之间存在一些差异。

1.3.2 使用

 public static void test1() {
        Deque<String> animals = new LinkedList<>();
        //在LinkedList的开始处添加元素
        animals.addFirst("Cow");
        animals.addFirst("Dog");
        animals.addFirst("Cat");
        System.out.println("LinkedList: " + animals);
        //在LinkedList的末尾添加元素
        animals.addLast("Zebra");
        System.out.println("新的LinkedList: " + animals);
    }

输出：

1.4 CopyOnWriteArrayList

CopyOnWriteArrayList是线程安全的ArrayList，使用写时复制的机制。

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

1.4.1 特点

优点：适合多线程环境下遍历频繁、修改少的场景，支持并发读取，解决开发工作中的多线程并发问题
缺点：

1. 内存占用问题：两个数组同时驻扎在内存中，如果实际应用中，数据比较多，而且比较大的情况下，占用内存会比较大，针对这个其实可以使用ConcurrentHashMap来代替。
2. 数据一致性：CopyOnWriteArrayList容器只能保证数据的最终已执行，不能保证数据的实时一致性，所以如果希望写入的数据，马上能读取到，就不能使用CopyOnWriteArrayList。

CopyOnWriteArrayList详细内容查看如下文章：
CopyOnWriteArrayList详解及使用

1.4.2 使用

public class myCopyOnWriteArrayList {

    public static void main(String[] args) {
        startTest();
    }
    private static final Integer THREAD_POOL_MAX_SIZE = 10;

    // 不支持并发
//    private static List<String> mList = new ArrayList<>();
    // 支持并发
    private static List<String> mList = new CopyOnWriteArrayList<>();
    
    private static void startTest() {
        // 初始化数据
        for (int i = 0; i < 10; i++) {
            mList.add("line:" + (i + 1) + "data");
        }
        System.out.println("------------初始化完成--------------------------");
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_MAX_SIZE);

        // 读写并发测试
        for (int i = 0; i < THREAD_POOL_MAX_SIZE; i++) {
            // 读任务立即执行
            executorService.execute(() -> {
                for (String item : mList) {
                    System.out.println(Thread.currentThread().getName() + "数据：" + item);
                }
            });
            final int final1 = i + 10;
            // 写任务立即执行
            executorService.execute(() -> {
                mList.add("写线程添加数据" + final1 + "..............");
            });
        }
    }
}

1.5 Arrays.asList()

Arrays.asList():将数组转换为List的静态方法。
List< String> list = Arrays.asList(“a”,“b”,“c”);
注意：

1.5.1 特点

特点：方便将数组转换为List，但返回的List不支持增删操作。

1.5.2 使用

 public static void test1(){
        //1、使用asList()的String数组，正常
        String[] strings = {"aa", "bb", "cc"};
        List<String> stringList = Arrays.asList(strings);
        System.out.print("1、使用asList()的String数组，正常：  ");
        for(String str : stringList){
            System.out.print(str + " ");
        }
        System.out.println();


        //2、使用asList()的对象类型(Integer)数组，正常
        Integer[] integers = new Integer[] {1, 2, 3};
        List<Integer> integerList = Arrays.asList(integers);
        System.out.print("2、使用asList()的对象类型数组，正常：  ");
        for(int i : integerList){
            System.out.print(i + " ");
        }
        System.out.println();


        //3、使用asList()的基本数据类型数组，出错
        int[] ints = new int[]{1, 2, 3};
        List intList = Arrays.asList(ints);
        System.out.print("3、使用asList()的基本数据类型数组，出错（将'ints'视为单个元素）：");
        for(Object o : intList){
            System.out.print(o.toString());
        }
        System.out.println();

        System.out.print("   " + "要正确输出，需按如下方式遍历：");
        int[] ints1 = (int[]) intList.get(0);
        for(int i : ints1){
            System.out.print(i + " ");
        }
        System.out.println();

        //4、更新数组或List时，另一个将自动更新
        System.out.print("4、更新数组或List时，另一个将自动更新：  ");
        integerList.set(0, 5);
        for(Object o : integerList){
            System.out.print(o + " ");
        }
        for(Object o : integers){
            System.out.print (o + " ");
        }
        System.out.println();

        //5、add() remove() 将报错
        System.out.print("5、add() remove() 将报错：  ");
//        integerList.remove(0);
//        integerList.add(3, 4);
//        integerList.clear();
    }

输出：

二、对比总结

参考链接：
Java LinkedList(链表)
CopyOnWriteArrayList详解及使用
Arrays.asList() 详解