Java学习总结（三）—— 集合、队列、栈、数组集合转换

1. 集合——Collection
   所有的集合都实现了Collection接口，有两个常见的Collection接口的子接口：

   1. java.util.List：可重复集合，并且有序
   2. java.util.Set：不可重复集合（实际编程中用到的比较少，暂不介绍）

2. List——Collection常见的子接口
   List有两个常见的实现类：

   1. java.util.ArrayList：使用数组实现，查询性能好
   2. java.util.LinkedList：使用链表实现，增删性能好，尤其是首位增删元素

3. 队列——非常经典的数据结构之一，可以保存一组元素，但是存取元素必须遵循先进先出原则

   1. 单端队列(Queue)：一头进一头出
   2. 双端队列(Deque)：每头都能进出，是单端队列的子接口
      LinkedList 也是它的一个常见实现类

4. 栈——数据结构，可以保存一组元素，但是存取元素必须遵循先进后出
   把双端队列的一端堵住，就是栈结构了(手动笑脸)。

5. 上述类的关系

   1. Collection的子接口是List、Queue
   2. ArrayList实现的接口只有List
   3. LinkedList实现的接口有List，Deque

6. 所有的集合都具有的常用的方法（也就是上述的都具有的方法）

   1. add：往集合的最后添加元素
   2. addAll：把一个集合中的所有元素添加到另一个集合中
   3. remove：从集合中删除指定的元素
   4. removeAll：从一个集合中删除和另一个集合的交集
   5. contains：判断集合中是否包含某个指定元素
   6. containsAll：判断两个集合是否具有交集

7. 三种遍历数组并删除元素的方法和区别（注意代码中的注释）

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("four");
		list.add("five");
		list.add("five");
		System.out.println(list);
		
		//利用for循环遍历list，并删除"three"
		for (int i = 0; i < list.size(); i++) {
			if ("three".equals(list.get(i))) {
				list.remove(i);
			}
		}
		//这种方式会改变list.size()的大小，无法遍历到所有的元素
		System.out.println(list);
		
		//利用新循环遍历list，并删除"four"
		for (String string : list) {
			if ("four".equals(string)) {
				list.remove(string);
				break;
				//如果list中只有一个"four"时可以正确执行
				//当有多个"four"时就会报错，所以加了break
			}
		}		
		System.out.println(list);
		
		//利用迭代器循环遍历list，并删除"five"
		Iterator<String> iterator = list.iterator();
		while (iterator.hasNext()) {
			if ("five".equals(iterator.next())) {
				iterator.remove();
			}
		}
		//这种方法不管有多少个"five"都能删除
		System.out.println(list);
		
		//总之：如果就删除集合中的某一个元素，可以采用新循环（记得break）
			  //如果要删除满足某个条件的所有元素，则采用迭代器
	}

1. 队列，栈常用的方法
   1. 单端队列(Queue)常用的方法：
      1. offer：在队列末尾添加某个元素，和add的功能一样
      2. poll：获取队列开头的元素，并删除
      3. peek：获取队列开头的元素，不删除
   2. 双端队列(Deque)常用的方法：
      1. offerFirst：在队列开头添加某个元素
      2. offerLast：在队列末尾添加某个元素，和offer功能一样
      3. pollFirst：获取队列开头的元素，并删除，和poll功能一样
      4. pollLast：获取队列末尾的元素，并删除
      5. peekFirst：获取队列开头的元素，不删除
      6. peekLast：获取队列末尾的元素，不删除
   3. 栈常用的方法：栈结构其实就是双端队列
      1. push：在队列开头添加元素，和offerFirst功能一样
      2. pop：获取队列开头元素，并删除
   4. 虽然这几种方法，不同的方法名，功能却一样，但是针对不同的应用场景要调用对应的方法，如果是栈的添加元素，虽然可以用offerFirst，但是最好还是用其对应的添加方法push
2. 数组集合之间的转换
   1. 数组转换为集合
      数组转换为集合，对集合的操作就是操作原数组，所以只能更新元素，不能增删元素

public static void main(String[] args) {
		String[] arr = {"one","two","three"};
		System.out.println("array: " + Arrays.toString(arr));
		
		List<String> list = Arrays.asList(arr);
		System.out.println(list);
		
		List<String> list2 = new ArrayList<>(list);	//把list集合进行复制，生成list2	
		System.out.println(list2);
		list2.add("five");
		System.out.println(list2);
｝

2. 集合转换为数组
   集合转换为数组，如果操作数组，和原集合没有关系，随便搞(手动笑脸)

public static void main(String[] args) {
		Collection<String> collection = new ArrayList<>();
		collection.add("one");
		collection.add("two");
		collection.add("three");
		collection.add("four");
		System.out.println(collection);
		
		String [] arr = collection.toArray(new String[collection.size()]);
		arr[1] = "1";
		System.out.println(arr.length);
		System.out.println(Arrays.toString(arr));
		
		System.out.println(collection);
	}