线性表——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;}@Overridepublic 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);}}