Java中的list集合

最新推荐文章于 2023-10-13 17:30:05 发布

了了i

最新推荐文章于 2023-10-13 17:30:05 发布

阅读量471

点赞数

分类专栏： java 文章标签： list Iterator List接口 Vector Stack

本文链接：https://blog.csdn.net/zhanghaobin1991/article/details/51386488

版权

java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

1、java.util.Collection [I]
   +--java.util.List [I]
       +--java.util.ArrayList [C]
       +--java.util.LinkedList [C]
       +--java.util.Vector [C]
           +--java.util.Stack [C]

   +--java.util.Set [I]
       +--java.util.HashSet [C]
       +--java.util.SortedSet [I]
           +--java.util.TreeSet [C]

  java.util.Map [I]
  +--java.util.SortedMap [I]
      +--java.util.TreeMap [C]
  +--java.util.Hashtable [C]
  +--java.util.HashMap [C]
  +--java.util.LinkedHashMap [C]
  +--java.util.WeakHashMap [C]

  2、集合概念以及集成结构：
   Collecation：集合层次中的根接口，JDK没有提供这个接口的实现类。
   List：可以包含重复的元素，是一个有序的集合，提供了按索引访问的方式。
   Set：不能包含重复的元素，子接口SortedSet是一个按照升序排列的元素的Set。
  3、Collection接口：
   1、 Collection是最基本的集合接口，
   一个Collection代表一组Object的集合，这些Object被称作Collection的元素。
       所有实现Collection接口的类都必须提供两个标准的构造函数：
   无参数的构造函数用于创建一个空的Collection，
   有一个Collection参数的构造函数用于创建一个新的Collection，
   这个新的Collection与传入的Collection有相同的元素。
   后一个构造函数允许用户复制一个Collection。
       如何遍历Collection中的每一个元素？
   不论Collection的实际类型如何，
   它都支持一个iterator()的方法，该方法返回一个迭代子，
   使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

   Iterator it = collection.iterator(); // 获得一个迭代子
   while(it.hasNext()) {
　　    Object obj = it.next(); // 得到下一个元素
   }

  4、泛型的使用：
   泛型，即“参数化类型”。
   一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
   那么参数化类型怎么理解呢？
   顾名思义，就是将类型由原来的具体的类型参数化，
   类似于方法中的变量参数，
   此时类型也定义成参数形式（可以称之为类型形参），
   然后在使用/调用时传入具体的类型（类型实参）

   Java泛型中的标记符含义：
    E - Element (在集合中使用，因为集合中存放的是元素)
    T - Type（Java 类）
    K - Key（键）
    V - Value（值）
    N - Number（数值类型）
   ？ - 表示不确定的java类型
    S、U、V - 2nd、3rd、4th types

5、Iterator：
Java中的Iterator功能比较简单，并且只能单向移动：

　　 a、使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。
注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

　　 b、使用next()获得序列中的下一个元素。

　　 c、使用hasNext()检查序列中是否还有元素。

　　 d、使用remove()将迭代器新返回的元素删除。

　　 Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，
它可以从两个方向遍历List，也可以从List中插入和删除元素。

  6、List接口：
   List继承自Collection接口。
   List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。
   用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，
   这类似于Java的数组。
       跟Set集合不同的是，List允许有重复元素。
   对于满足e1.equals(e2)条件的e1与e2对象元素，
   可以同时存在于List集合中。
   当然，也有List的实现类不允许重复元素的存在。
      除了具有Collection接口必备的iterator()方法外，
   List还提供一个listIterator()方法，返回一个 ListIterator接口，
   和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，
   允许添加，删除，设定元素，还能向前或向后遍历。
      实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

package main;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;

public class CoreJavaDay14_2 {
public static void main(String[] args) {
  LinkedList<String> linkdeList = new LinkedList<>();
  ArrayList<String> arrayList = new ArrayList<>();
  System.out.println("start");
  // LinkedList 增加数据
  long time1 = System.currentTimeMillis();
  for (int i = 1; i <= 900000; i++) {
   linkdeList.add(String.valueOf(i));
  }
  long time2 = System.currentTimeMillis();

System.out.println("LinkedList,增加元素" + (time2 - time1));

  // ArrayList 增加数据
  long time3 = System.currentTimeMillis();
  for (int i = 1; i <= 900000; i++) {
   arrayList.add(String.valueOf(i));
  }
  long time4 = System.currentTimeMillis();

System.out.println("ArrayList,增加元素" + (time4 - time3));

  // LinkedList 插入数据
  long time1_1 = System.currentTimeMillis();
  for (int i = 1; i <= 10000; i++) {
//   list1.add(0, String.valueOf(i));
   linkdeList.addFirst(String.valueOf(i));
  }
  long time2_1 = System.currentTimeMillis();

System.out.println("LinkedList,插入元素" + (time2_1 - time1_1));

  // ArrayList 插入数据
  long time3_1 = System.currentTimeMillis();
  for (int i = 1; i <= 10000; i++) {
   arrayList.add(0, String.valueOf(i));
  }
  long time4_1 = System.currentTimeMillis();

System.out.println("ArrayList,插入元素" + (time4_1 - time3_1));

  // LinkedList 访问数据
  long time5 = System.currentTimeMillis();
  for (int i = 0; i < linkdeList.size() / 100; i++) {
   linkdeList.get(i);
  }
  long time6 = System.currentTimeMillis();
  System.out.println("LinkedList,访问元素" + (time6 - time5));

  // ArrayList 访问数据
  long time7 = System.currentTimeMillis();
  for (int i = 0; i < arrayList.size() / 100; i++) {
   arrayList.get(i);
  }
  long time8 = System.currentTimeMillis();
  System.out.println("ArrayList,访问元素" + (time8 - time7));

  // LinkedList 删除数据
  long time9 = System.currentTimeMillis();
  for (int i = 0; i < linkdeList.size() / 100; i++) {
   linkdeList.remove(i);
  }
  long time10 = System.currentTimeMillis();
  System.out.println("LinkedList,删除元素" + (time10 - time9));

  // ArrayList 删除数据
  long time11 = System.currentTimeMillis();
  for (int i = 0; i < arrayList.size() / 100; i++) {
   arrayList.remove(i);
  }
  long time12 = System.currentTimeMillis();
  System.out.println("ArrayList,删除元素" + (time12 - time11));

  Stack<String> stack = new Stack<>();
  long time13 = System.currentTimeMillis();
  for (int i = 1; i <= 900000; i++) {
   stack.add(String.valueOf(i));
  }
  long time14 = System.currentTimeMillis();
  System.out.println("stack,增加元素" + (time14 - time13));

}

  7、Vector：
   Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，
   虽然和ArrayList创建的 Iterator是同一接口，
   但是，因为Vector是同步的，当一个
   Iterator被创建而且正在被使用，
   另一个线程改变了Vector的状态（例如，添加或删除了一些元素），
   这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

  8、Stack：
   Stack继承自Vector，实现一个后进先出的堆栈。
   Stack提供5个额外的方法使得Vector得以被当作堆栈使用。
   基本的push和pop方法，
   还有peek方法得到栈顶的元素，
   empty方法测试堆栈是否为空，
   search方法检测一个元素在堆栈中的位置。
   Stack刚创建后是空栈。

package main;

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

public class CoreJavaDay14 {
public static void main(String[] args) {
  //1、用for循环为List添加a~n
  //2、用迭代器进行遍历输出
  System.out.println(-1 >>> 1);
  System.out.println((-1 >>> 1) + 1);
  long sum = 40076l * 1000l * 100l;

//  ArrayList<String> list = new ArrayList<>();
//  for(char i = 'a'; i <= 'n'; i++){
//   list.add(String.valueOf(i));
//  }
//  System.out.println(list.toString());
//
//  Iterator<String> iterator = list.iterator();
//  while (iterator.hasNext()) {
//   System.out.println("while---" + iterator.next());
//  }
//
//  iterator = list.iterator();
//  for(;iterator.hasNext();){
//   System.out.println("for---" + iterator.next());
//  }
}
}

package main;

import java.util.ArrayList;
import java.util.LinkedList;

public class CoreJavaDay14_3 {
public static void main(String[] args) {
  long time1 = System.currentTimeMillis();
  calculate1();
  long time2 = System.currentTimeMillis();
  System.out.println("时间：" + (time2 - time1));

  long time3 = System.currentTimeMillis();
  calculate2();
  long time4 = System.currentTimeMillis();
  System.out.println("时间：" + (time4 - time3));
}

/*
* ArrayList
*/
public static void calculate1(){
  int n = 50000;
  ArrayList<Tea> list = new ArrayList<>();
  //添加奶茶
  for(int i = 0; i < n; i++){
   list.add(new Tea(i + 1));
  }

  //喝掉奶茶
  for(int i = n - 1; i > 0; i--){
   if(list.get(i).getCode() % 4 == 0){
    list.remove(i);
   }
  }
  System.out.println("剩余" + list.size() + "杯");
  System.out.println("第倒数1000杯" + list.get(list.size() - 1000).getCode());
}

/*
* LinkedList
*/
public static void calculate2(){
  int n = 50000;
  LinkedList<Tea> list = new LinkedList<>();
  //添加奶茶
  for(int i = 0; i < n; i++){
   list.add(new Tea(i + 1));
  }
  //喝掉奶茶
  for(int i = n - 1; i > 0; i--){
   if(list.get(i).getCode() % 4 == 0){
    list.remove(i);
   }
  }
  System.out.println("剩余" + list.size() + "杯");
  System.out.println("第倒数1000杯" + list.get(list.size() - 1000).getCode());
}