线性表——List（集合）

 

1.List集合的特点是：可重复，并且有序。List提供了一组独有的方法，特点都是可以通过下标操作元素。

 

list.add(1,"2"); list.remove(2);

 

package day08;

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

/**
 * java.util.List
 * List是Collection的一个常用子接口。
 * List集合的特点是：可重复，并且有序。
 * List提供了一组独有的方法，特点都是可以通过下标操作元素。
 * （Set集合并不具备这些方法）
 * @author soft01
 *
 */
public class List_add_remove {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		System.out.println(list);
		/*
		 * void add(int index,E e)
		 * 将给定元素插入到指定位置
		 */
		//[one,2,two,three,four]
		list.add(1,"2");
		System.out.println(list);
		
		/*
		 * E remove(int index)
		 * 从集合中删除指定位置的元素
		 * 返回值为被删除的元素。
		 */
		//[one,2,three,four]
		String old = list.remove(2);
		System.out.println(list);
		System.out.println("被删除的元素是："+old);
	}
}

2.List提供的基于下标操作方法之：get，set

 

 

 

 

package day08;

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

/**
 * List提供的基于下标操作方法之：get，set
 * @author soft01
 *
 */
public class List_get_set {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		System.out.println(list);
		/*
		 * E get(int index)
		 * 获取指定位置上的元素
		 */
		//String str = array[1]
		String str = list.get(1);
		System.out.println(str);
		for(int i=0;i<list.size();i++) {
			str = list.get(i);
			System.out.println(str);
		}
		/*
		 * E set(int index,E e)
		 * 将给定元素设置到指定位置，返回值为原位置对应的元素。
		 * 所以set方法是替换元素操作。
		 */
		//[one,2,three,four]
		String old = list.set(1, "2");
		System.out.println(list);
		System.out.println(old);
	}
}

3.List提供了可以获取子集的方法：List subList(int start,int end)

 

 

 

 

package day08;

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

/**
 * List提供了可以获取子集的方法：
 * List subList(int start,int end)
 * 获取当前集合指定范围内的子集
 * @author soft01
 *
 */
public class List_subList {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<10;i++) {
			list.add(i);
		}
		//[0,1,2,3,4,5,6,7,8,9]
		System.out.println(list);
		
		//[3,4,5,6,7]
		List<Integer> subList = list.subList(3, 8);
		System.out.println("sub:"+subList);
		
		//将子集元素扩大10倍
		//[30,40,50,60,70]
		for(int i=0;i<subList.size();i++) {
			subList.set(i, subList.get(i)*10);
		}
		System.out.println(subList);
		/*
		 * 对一个集合的子集元素操作就是对该集合对应元素的操作
		 */
		System.out.println(list);
		/*
		 * 将list集合中2-8的元素删除
		 * 
		 * [0,1,2,30,40,50,60,70,8,9]
		 * [0,1,9]
		 */
		/*for(int i=2;i<=8;i++) {
			list.remove(2);
		}*/
//		list.removeAll(list.subList(2,9));
		list.subList(2,9).clear();
		System.out.println(list);
	}
}

4.集合转换为数组的方法：toArray();

 

 

 

 

package day08;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 所有集合都可以转换为数组，Collection定义了
 * 集合转换为数组的方法：toArray
 * @author soft01
 *
 */
public class CollectionToArrayDemo {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		c.add("one");
		c.add("two");
		c.add("three");
		c.add("four");
		System.out.println(c);
		/*
		 * 将集合转换为数组
		 */
//		Object[] array = c.toArray();
		String[] array = c.toArray(new String[c.size()]);
		System.out.println("len:"+array.length);
		for(String str : array) {
			System.out.println(str);
		}
	}
}

5.数组转换为集合的方法：Arrays.asList();

 

 

 

 

package day08;

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

/**
 * 数组转换为集合
 * 通过数组的工具类Arrays的方法asList实现。
 * 
 * 需要注意，该方法仅能将数组转换为List集合
 * @author soft01
 *
 */
public class ArrayToListDemo {
	public static void main(String[] args) {
		String[] array = {"one","two","three","four","five"};
		
		List<String> list = Arrays.asList(array);
		System.out.println("size："+list.size());
		System.out.println(list);
		/*
		 * 将集合元素改变为：
		 * [one,2,three,four,five]
		 */
		list.set(1, "2");
		System.out.println(list);
		/*
		 * 当将一个数组转换为集合后，对该集合元素
		 * 操作就是对原数组对应元素的操作。
		 */
		System.out.println(Arrays.toString(array));
		/*
		 * 向集合中添加新元素：six
		 */
//		list.add("six");//错误，原数组没扩容
//		System.out.println(list);
		
		/*array = Arrays.copyOf(array,array.length+1);
//		array[array.length-1]="six";
		list = Arrays.asList(array);
		list.set(list.size()-1, "six");
		System.out.println(list);
		System.out.println(Arrays.toString(array));*/
		
		List<String> list1 = new ArrayList<String>(list);
		list1.add("six");
		System.out.println(list1);
	}
}

6.集合的排序:Collections.sort();

 

 

 

 

package day08;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * 集合的排序
 * 需要注意，仅能对List集合进行排序。
 * 排序可以使用集合的工具类：java.util.Collections
 * 其提供了一个静态方法sort可以对List集合进行自然排序（从小到大）
 * @author soft01
 *
 */
public class Collections_sort {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		
		Random rand = new Random();
		for(int i=0;i<10;i++) {
			list.add(rand.nextInt(100));
		}
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
	}
}

7.自定义排序:实现Comparable接口，必须重写方法：compareTo

使用当前类作为集合元素测试集合对自定义类型元素的排序。

 

 

 

 

package day08;
/**
 * 使用当前类作为集合元素测试集合对自定义类型元素的排序。
 * @author soft01
 *
 */
public class Point2 /*implements Comparable<Point2>*/{
	private int x;
	private int y;
	
	public Point2() {
		super();
	}
	
	public Point2(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}

	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	@Override
	public String toString() {
		return " (" + x + ", " + y + ")";
	}

	/**
	 * 当一个类实现了Comparable接口后，
	 * 就要求必须重写方法：compareTo
	 * 该方法的作用是用当前对象（this）与参数对象o比较大小。
	 * 返回值是一个整数，返回值并不关注具体取值，
	 * 而关注的是取值范围：
	 * 当返回值>0：即表示当前对象大于参数对象（this>0）
	 * 当返回值<0：即表示当前对象小于于参数对象
	 * 当返回值=0：两个对象相等
	 */
	/*public int compareTo(Point2 o) {
		
		 * 点到原点的距离长的大
		 
		int len = this.x*this.x + this.y*this.y;
		int olen = o.x*o.x+o.y*o.y;
		return len-olen;
	}*/
	
}

 

package day08;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 排序含有自定义类型元素的List
 * @author soft01
 *
 */
public class Collections_sort2 {
	public static void main(String[] args) {
		List<Point2> list = new ArrayList<Point2>();
		list.add(new Point2(5,6));
		list.add(new Point2(4,7));
		list.add(new Point2(2,1));
		list.add(new Point2(8,9));
		list.add(new Point2(7,9));
		System.out.println(list);
		/*
		 * Collections的sort方法在排序List集合时
		 * 要求该集合的元素必须实现：Comparable接口。
		 * 该接口规定了元素可以比较大小。
		 */
//		Collections.sort(list);
		/*
		 * 排序自定义类型元素时，推荐使用下面的重载sort方法，
		 * 该方法要求传入一个额外的比较器，使用匿名内部类即可。
		 * 这样一句代码就可以完成排序操作。而无需在Point2类中
		 * 实现接口并为其提供一个方法。
		 * 
		 * 当我们使用某个功能时，该功能要求我们为其修改代码越多，
		 * 侵入性越强。实际开发中应尽量避免侵入性强的功能。
		 */
		Collections.sort(list, new Comparator<Point2>() {
			public int compare(Point2 o1,Point2 o2) {
				int len1 =o1.getX()*o1.getX()+o1.getY()*o1.getY();
				int len2 =o2.getX()*o2.getX()+o2.getY()*o2.getY(); 
				return len1-len2;
			}
		});
		System.out.println(list);
	}
}

8.建议：匿名内部类实现Comparator接口（比较好改动）：必须重写方法：compare

 

 

 

 

package day08;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Collections_sort3 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("perfume");
		list.add("rose");
		list.add("linsa");
		System.out.println(list);
//		Collections.sort(list);
		
		/*
		 * Comparator
		 */
		Collections.sort(list,new Comparator<String>() {
			public int compare(String o1,String o2) {
				return o1.length()-o2.length();
			}
		});
		System.out.println(list);
	}
}

9.队列 ：Queue——LinkedList(peek()——获取队首元素(不删除))
offer() 入队操作，向队列末尾追加给定元素。
poll() 出队操作，获取队首元素，获取后该元素即从队列中被移除。

 

 

 

 

package day08;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 队列
 * 队列用于存放一组元素，但是存取元素只能从“两端”进行
 * 且遵循“先进先出”原则。
 * FIFI,First Input First Output
 * 
 * java.util.Queue 队列接口，规定了队列相关方法
 * @author soft01
 *
 */
public class QueueDemo {
	public static void main(String[] args) {
		Queue<String> queue = new LinkedList<String>();
		/*
		 * boolean offer(E e)
		 * 入队操作，向队列末尾追加给定元素
		 */
		queue.offer("one");
		queue.offer("two");
		queue.offer("three");
		queue.offer("four");
		
		System.out.println(queue);
		/*
		 * E poll()
		 * 出队操作，获取队首元素，获取后该元素即
		 * 从队列中被移除。
		 */
		String str = queue.poll();
		System.out.println(str);
		System.out.println(queue);
		
		//遍历队列元素
		/*while(queue.size()>0) {
			str = queue.poll();
			System.out.println(str);
		}*/
		
		//遍历队列元素
		for(String s : queue) {
			System.out.println(s);
		}
		System.out.println(queue);
	}
}

10.双端队列Deque——若一端即实现“栈”(Stack)的数据结构
offerFirst()——push()——入栈;pollFirst()——pop()——出栈;
offerLast();pollLast();
peekFirst();peekLast();

 

 

 

 

package day08;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 双端队列Deque
 * java.util.Deque是Queue的子接口，
 * 规定了双端队列的相关方法。
 * 双端队列的特点是可以分别从队列首尾进出队操作。
 * 双端队列提供了更有方向的进出队方法。
 * @author soft01
 *
 */
public class DequeDemo {
	public static void main(String[] args) {
		Deque<String> deque = new LinkedList<String>();
		deque.offer("red");
		deque.offer("orange");
		System.out.println(deque);
		
		deque.offerFirst("yellow");
		System.out.println(deque);
		
		deque.offerLast("green");
		System.out.println(deque);
		
		/*
		 * 队列提供了引用队首元素方法peek，
		 * 它与poll的区别在于获取后该元素依然在队列中。
		 * 在双端队列中还支持peekFirst,peekLast
		 */
		String str = deque.peek();
		System.out.println(str);
		System.out.println(deque);
		
		str = deque.pollFirst();
		System.out.println(str);
		System.out.println(deque);
		
		str = deque.pollLast();
		System.out.println(str);
		System.out.println(deque);
	}
}

11.栈——先进后出原则
push()——入为第一个元素
pop()——出删第一个元素

 

 

 

 

package day08;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 栈
 * 栈用来存一组元素，但是存取元素必须遵循先进后出原则，
 * 通常使用栈来实现“后退”功能。
 * @author soft01
 *
 */
public class StackDemo {
	public static void main(String[] args) {
		Deque<String> stack = new LinkedList<String>();
		stack.push("red");
		stack.push("orange");
		stack.push("yellow");
		stack.push("green");
		stack.push("cyan");
		System.out.println(stack);
		
		String str = stack.pop();
		System.out.println(str);
		System.out.println(stack);
		
		while(stack.size()>0) {
			str = stack.pop();
			System.out.println(str);
		}
		System.out.println(stack);
	}
}