021 Java线性表

1.List

1.1ArrayList和LinkedList

List接口是Collection的接口，用于定义线性表数据结构。可以将其理解为存放对象的数组，只不过可以动态的增加或减少。

List分为两个常见的实现类分为ArrayList和LinkedList，分别分为动态数组和链表实现List接口。

   其中，ArrayList适合于随机访问，LinkedList适合于插入和删除。

1.2get和set方法

get(int index):获取指定下标对应的元素，下标从零开始

set(int index,E element):将给定的元素存入给定的位置，并将原位置的元素返回。

代码如下：

/*
	 * 测试set方法和get方法
	 */
	@Test
	public void testSetAndGet(){
		List<String>list=new ArrayList<String>();
		list.add("java");
		list.add("cpp");
		list.add("php");
		list.add("c#");
		list.add("object-c");
		System.out.println(list);
		//[java, cpp, php, c#, object-c]
		for(int i=0;i<list.size();i++){
			System.out.print(list.get(i)+" ");
		}
		//java cpp php c# object-c cpp
		
		String value=list.set(1,"c++");
		System.out.println(value);
		System.out.println(list);
		//[java, c++, php, c#, object-c]
		
		//交换位置1和位置3的位置
		
		list.set(1,list.set(3,list.get(1)));
		System.out.println(list);
		//[java, c#, php, c++, object-c]
		
	}

1.3插入和删除

void add(int index,E element):将给定的元素插入到指定位置，原位置以及后续元素都顺序向后移动

E remove(int index):删除给定位置的元素，并将删除的元素返回

/*
	 * 测试插入和删除元素
	 */
	@Test
	public void testInsertAndDelete(){
		List<String>list=new ArrayList<String>();
		list.add("java");
		list.add("c#");
		System.out.println(list);
		//[java, c#]
		list.add(1,"cpp");
		System.out.println(list);
		//[java, cpp, c#]
		list.remove(2);
		System.out.println(list);
		//[java, cpp]
	}

1.4subList

subList用于获取子List

注意：list只存对象的地质，subList获取的List和原List占有相同的存储空间，对子subList操作会影响原List

具体代码如下：

	/*
	 * 测试subList方法
	 */
	@Test
	public void testSubList(){
		List<Integer>list=new ArrayList<Integer>();
		for(int i=0;i<10;i++){
			list.add(i);
		}
		System.out.println(list);
		//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
		List<Integer>subList=list.subList(3,8);
		System.out.println(subList);
		//[3, 4, 5, 6, 7]
		for(int i=0;i<subList.size();i++){
			subList.set(i,subList.get(i)*10);
		}
		System.out.println(list);
		//[0, 1, 2, 30, 40, 50, 60, 70, 8, 9]

		System.out.println(subList);
		//[30, 40, 50, 60, 70]

	}
	

1.5List转换为数组

List的toArray方法用于将集合转换为数组，但实际方法在Collection中定义，所以所有的集合都具备T个功能，一般方法为：<T>T[]toArray(t[] a),代码如下：

@Test
	public void listToArray(){
		List<String>list=new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		String[]strArr=list.toArray(new String[]{});
		System.out.println(Arrays.toString(strArr));
		//[a, b, c]
		
	}

1.6数组转换为List

Arrays提供一个静态方法asList，使用该方法我们可以将一个数组转换为对应的List集合

注意：返回的元素我们不能对其进行增删元素，否则抛出异常。并且对集合的修改会影响数组对应元素

代码如下：

	/*
	 * 测试asList方法
	 */
	@Test
	public void testAsList(){
		String[] str={"a","b","c"};
		List<String>list=Arrays.asList(str);
		System.out.println(list);
		//[a, b, c]
		//list.add("d");
		//不能进行增删操作
	}
	

2.List排序

2.1Collections.sort方法实现排序

Collections是集合的工具类，提供了很多我们便于操作集合方法，其中就有集合排序的sort方法

具体代码如下：

	/*
	 * 测试sort方法
	 */
	@Test
	public void testSort(){
		List<Integer>list=new ArrayList<Integer>();
		Random random=new Random(1);
		for(int i=0;i<10;i++){
			list.add(random.nextInt(100));
		}
		System.out.println(list);
		//[85, 88, 47, 13, 54, 4, 34, 6, 78, 48]
		Collections.sort(list);
		System.out.println(list);
		//[85, 88, 47, 13, 54, 4, 34, 6, 78, 48]
		

2.2Comparable

Collections的sort方法是对集合元素进行自然排序，那两个元素之间必然要有大小写之分。因而我们可以通过实现类实现接口Comparable,该接口表示子类是可比较的，因为该实现类必须重写抽象方法

该方法用于当前对象和给定对象进行比较

若当前对象大于给定对象，返回值大于零

若当前对象小于给定对象，返回值小于零

        若当前对象等于给定对象，返回值等于零

2.3Comparator

一旦Java实现了Comparable接口，其比较逻辑就已经确定，如果希望排序操作中零食的指定比较规则，可以采用Comparator,代码如下：

	/*
	 * 测试conparator方法
	 */
	@Test
	public void testComparator(){
		List<Cell>cells=new ArrayList<Cell>();
		cells.add(new Cell(2,3));
	    cells.add(new Cell(5,1));
	    cells.add(new Cell(3,2));
	    
	    //按col的值得大小排序
	    Collections.sort(cells,new Comparator<Cell>(){
	    	public int compare(Cell o1,Cell o2){
	    		return o1.col-o2.col;
	    	}
	    });
	    System.out.println(cells);
	    //[5,1, 3,2, 2,3]
	}

3.队列和栈

3.1Queue

队列：将队列看成是线性表，队列限制了线性表的存储方式，只能从一段进栈，从另一端出栈

遵循（Filst input First Output）FIFO：队列先进先出

JDK提供了Queue接口，同时是LinkedList实现了该接口

队列的只要方法有：

   1.offer：将元素添加到队尾

2.poll：从对首删除一个元素并返回

3.peek 返回队首元素

代码如下：

	@Test
	public void testQueue(){
		Queue<String>queue=new LinkedList<String>();
		queue.offer("a");
		queue.offer("b");
		queue.offer("c");
		System.out.println(queue);
		//[a, b, c]
		String str=queue.peek();
		System.out.println(str);
		//a
		while(queue.size()>0){
			String str1=queue.poll();
			System.out.print(str1+" ");
		}
		//a b c 
	}

3.2Deque

Deque是Queue的子接口，定义了所谓双端队列，从队列的两端进行入队（offer）出队（poll）

如果将Deque限制只能从一段入队和出队，则可实现“栈”的数据结构，对于栈而言，入栈为push出栈为pop

遵循先进后出原则（First input Last Output）

代码如下：

/*
	 * 测试stack方法
	 */
	@Test
	public void testStack(){
		Deque<String>stack=new LinkedList<String>();
		stack.push("a");
		stack.push("b");
		stack.push("c");
		System.out.println(stack);
		//[c, b, a]
		String str=stack.peek();
		System.out.println(str);
		//c
		
		while(stack.size()>0){
			str=stack.poll();
			System.out.print(str+" ");
		}
		//c b a 
	}