Java集合(List集合)

什么是集合？
什么是集合？集合就是“由若干个确定的元素所构成的整体”，在程序中，一般代表保存
若干个元素（数据）的某种容器类。

在Java中，如果一个Java对象可以在内部持有（保存）若干其他Java对象，并对
外提供访问接口，我们把这种Java对象的容器称为集合。很显然，Java的数组也可以看作
是一种集合：
 

既然]ava提供了数组这种数据类型，可以充当集合，那么，我们为什么还需要其他集合
类？这是因为数组有如下限制：
·数组初始化后大小不可变：
·数组只能按索引顺序存取；
因此，我们需要各种不同类型的集合类来处理不同的数据，例如：
·可变大小的顺序链表；
·保证无重复元素的集合：
 

 集合接口
Java标准库自带的java.util包提供了集合相关的接口和实现类：
Collectioni接口，它是除Map接口外所有其他集合类的根接口。
Java的java.util包主要提供了以下三种类型的集合：
List:一种有序列表的集合：
Set:一种保证没有重复元素的集合：
Map:一种通过键值(key-value)查找的映射表集合，例如，根据Student的name查找对应Student的Map。

 ArrayList

package com.xn.ffur;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Fur02 {
	public static void main(String[] args) {
		//创建临时的List集合
		List<String> foodlist=Arrays.asList("馅饼","胡辣汤","油条","包子","窝窝头","豆浆","馒头");
		//全部添加至ArrayList集合中
		ArrayList<String> list=new ArrayList<String>();
		list.addAll(foodlist);
		
		//操作1：添加新元素
		//add(E,e)方法：添加元素至集合的尾部
		list.add("三明治");
		System.out.println(list);
		
		//操作2：获取元素(按照下标位置，获取元素)
		//get(int index)
		String first=list.get(0);
		System.out.println("首元素"+first);
		String last=list.get(list.size()-1);
		System.out.println("尾元素"+last);
		
		//操作3：查找元素
		//indexOf(Object o)
		int index1=list.indexOf(first);
		System.out.println("查找一个存在的元素时："+index1);
		int index2=list.indexOf(last);
		System.out.println("查找一个存在的元素时："+index2);
		
		//操作4：删除元素(按照下标或值，进行删除)
		//remove(int index)按下标删除
		//remove(Object value)按值删除
		
		System.out.println(list);
		list.remove("豆浆");
		System.out.println("删除后："+list);
		
		//操作5：修改元素
		//set(int index,E e):按照下标位置修改
		System.out.println("修改前："+list);
		list.set(2, "汉堡");
		System.out.println("修改后"+list);
		
		//查看元素是否存在
		boolean isContains=list.contains("馅饼");
		System.out.println(isContains);
		//截取子集合
		List<String> sub=list.subList(1, 5);
		System.out.println(sub);
		//转化成数组
		Object[] arr1=list.toArray();
		String[] arr2=list.toArray(new String[list.size()]);
		System.out.println(Arrays.toString(arr1));
		System.out.println(Arrays.toString(arr2));
		//清空
		list.clear();
		System.out.println(list);
	}
}

package com.xn.ffur;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class Fur03 {
	public static <T> void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.addAll(Arrays.asList("E", "A", "N", "C", "P", "Z"));
		// 方式1：冒泡排序
		for(int i=0,n=list.size();i<n-1;i++) {
			for(int k=0;k<n-i-1;k++) {
				while(list.get(k).compareTo(list.get(k+1))>0) {
					String temp=list.get(k);
					list.set(k, list.get(k+1));
					list.set(k+1, temp);
				}
			}
		}
		System.out.println(list);
		// 方式2：使用sort()方法
		list = new ArrayList<String>();
		list.addAll(Arrays.asList("C", "Y", "O", "R", "T", "D"));
		list.sort(new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});
		System.out.println(list);
	}
}

package com.xn.ffur;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public class Fur04 {
	public static void main(String[] args) {
		//通过无参构造方法创造Array List集合
		//数组默认被初始化成一个空数组
		ArrayList<Integer> list1=new ArrayList<Integer>();
		list1.add(1);//添加第1个元素时，将数组扩容为10
		list1.add(2);
		//添加第11个元素时，容量不足，再次将数组扩容，按照原容量的1.5倍
		
		//通过【有参构造方法】创建ArrayList集合
		//根据预估数据元素的规模数量，初始化elementData数组
		//减少扩容的次数频率

		ArrayList<Integer> list2=new ArrayList<Integer>(100);
		//创建集合时，传入另外一个Collection集合，并且按照该集合的元素进行初始化
		ArrayList<Integer> list3=new ArrayList<Integer>(Arrays.asList(100,101,102));
	}
}

LinkedList

package com.xn.ffur;

import java.util.LinkedList;

public class Fur05 {
	public static void main(String[] args) {
		LinkedList<String> list=new LinkedList<String>();
		//添加新元素
		//add()/list.addLate():将新元素提娜佳至链表的尾部
		list.add("a");
		list.add("b");
		list.add("c");	
		list.add("d");	
		list.add("e");	
		list.addFirst("f");
		//将新元素提娜佳至链表的尾部
		list.addLast("l");
		System.out.println(list);
		//获取元素
		//过呢据元素的下标位置，在链表中遍历，查找获取元素
		String item=list.get(1);
		System.out.println(item);
		//获取链表的头元素和尾元素
		String  first=list.getFirst();
		String last=list.getLast();
		System.out.println(first);
		//删除元素
		list.remove(1);//根据下表删除
		list.remove("b");//根据值
		list.removeFirst();//删除链表的头元素
		list.removeLast();//删除链表的尾元素
	}
}

Stack栈

package com.xn.ffur;

import java.util.Stack;
import java.util.Vector;

public class Fur06 {
	public static void main(String[] args) {
		//创建栈
		Stack<String> stack=new Stack<String>();
		//添加新元素（向栈顶添加）
		stack.push("s1");
		stack.push("s2");
		stack.push("s3");
		stack.push("s4");
		stack.push("s5");
		stack.push("s6");
		System.out.println(stack);
		
		//获取元素（从栈顶获取并删除元素）
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack);
		
		//取出栈顶元素
		System.out.println(stack.peek());
		System.out.println(stack.peek());
		
		//遍历栈
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());
		}
	}
}

package com.xn.ffur;

import java.util.Stack;

public class Fur07 {
	public static void main(String[] args) {
		//方式1;Stack栈
		String s="长江后浪推前浪";
		Stack<Character> stack=new Stack<Character>();
		for(int i=0;i<s.length();i++) {
			char c=s.charAt(i);
			stack.push(c);
		}
		StringBuilder ret=new StringBuilder();
		while(!stack.isEmpty()) {
			ret.append(stack.pop());
		}
		System.out.println(ret);
		
		//方式2:StringBuilder
		StringBuilder sb=new StringBuilder();
		sb.reverse();
		System.out.println(sb);
	}
}