本文共 11272 字，大约阅读时间需要 37 分钟。
【JavaSE】day05_List集合_List排序_队列和栈
1）有序集，可重复集。List的特点是可以像数组一样，根据下标操作元素。所以List提供了一些独有的方法。
2）常用实现类：
--ArrayList：内部由数组实现，查询快。
--LinkedList：内部由链表实现，增删快。
3）E get(int index)
获取指定下标对应的元素。(下标从0开始)
4）E set(int index,E e)
将给定的元素设置到指定的位置上，返回值为原位置上的元素。所以该操作是替换元素操作。
注：需在现有的元素上进行操作。
代码演示：
package day04;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * List集合 * 有序集，可重复集。 * List的特点是可以像数组一样，根据下标操作元素。 * 所以List提供了一些独有的方法。 * 常用实现类： * ArrayList：内部由数组实现，查询快。 * LinkedList：内部由链表实现，增删快。 * */public class ListDemo01 { public static void main(String[] args) { List list = new ArrayList (); list.add("one"); list.add("two"); list.add("three"); list.add("four"); /* * E get(int index) * 获取指定下标对应的元素。(下标从0开始) */ String str = list.get(0); System.out.println(str); //one //遍历全部元素 //1. for(int i=0;i it = list.iterator(); while(it.hasNext()){ str = it.next(); System.out.print(str+" "); } System.out.println(); /* * E set(int index,E e) * 将给定的元素设置到指定的位置上，返回值为原位置 * 上的元素。所以该操作是替换元素操作。 * 注：需在现有的元素上进行操作。 */ //[one,2,three,four] String old = list.set(1,"2"); System.out.println(list); System.out.println("被替换掉的元素为："+old); list.add(2,"###"); list.add(5,"1"); System.out.println(list); }} 5）void add(int index,E e) 向指定位置插入给定元素，原位置及后续元素顺序向后移动。
6）E remove(int index)
删除并返回给定位置的元素。
代码演示：
package day04;import java.util.LinkedList;import java.util.List;/** * List提供的另一对方法： * void add(int index,E e) * 向指定位置插入给定元素，原位置及后续元素顺序向后移动。 * * E remove(int index) * 删除并返回给定位置的元素。 * */public class ListDemo02 { public static void main(String[] args) { List list = new LinkedList (); list.add("one"); list.add("two"); list.add("three"); list.add("four"); System.out.println(list); //[one, two, three, four] //[one, two, 3, three, four] list.add(2,"3"); System.out.println(list); //[one, two, 3, three, four //[one, two, 3, three, four, 5] //在末尾追加一个 list.add(5,"5"); System.out.println(list); //[one, two, 3, three, four, 5] //[one, two, 3, four, 5] String old = list.remove(3); //下标不能越界 System.out.println(list); //[one, two, 3, four, 5] System.out.println("被删除的元素是："+old); //three System.out.println(list.get(3)); }} 7）List subList(int start,int end) 获取当前集合中给定范围内的部分子集
对子集的任何操作都会影响原集合。
清空子集，原集合中该部分内容也被删除。通过清空子集来快速删除原集合的指定内容。
代码演示：
package day04;import java.util.ArrayList;import java.util.List;/** * 获取List集合中的子集 * */public class ListDemo03 { public static void main(String[] args) { List list = new ArrayList (); 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 subList(int start,int end) * 获取当前集合中给定范围内的部分子集 */ List subList = list.subList(3,8); System.out.println(subList); //[3, 4, 5, 6, 7] //将子集中的每个元素扩大10倍 for(int i=0;i 8）集合转换成数组 Collection中提供了一个方法toArray，允许我们将现有的集合转换为数组。
代码演示：
package day04;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;/** * 集合转换成数组 * Collection中提供了一个方法toArray * 允许我们将现有的集合转换为数组。 * */public class ColletionToArray { public static void main(String[] args) { Collection c = new ArrayList (); c.add("one"); c.add("two"); c.add("three"); c.add("four"); String[] array = c.toArray(new String[c.size()]); System.out.println(Arrays.toString(array)); //[one, two, three, four] array[0]="1"; System.out.println(Arrays.toString(array)); //[1, two, three, four] System.out.println(c); //[one, two, three, four] c.add("##"); System.out.println(Arrays.toString(array)); //[1, two, three, four] System.out.println(c); //[one, two, three, four, ##] /* * 总结：当把集合转化成数组后，可以对集合中的元素进行增删改查操作 * 两者之间互不影响。 * 当集合中存的是对象时，当改变对象中的属性的值时，都会跟着改变。 */ }} 9）数组转换成集合 使用Arrays的静态方法asList()需要注意，数组只能转换为List集合，不能转换成Set。原因：
* 1.Set大部分是无序实现
* 2.Set不允许存放重复元素，所以转换后可能丢失元素。
对于由数组转换的集合来说，添加元素是不受支持的！
代码演示：
package day04;import java.util.ArrayList;import java.util.Arrays;import java.util.List;/** * 数组转换成集合 * 使用Arrays的静态方法asList() * 需要注意，数组只能转换为List集合，不能转换成Set。 * 原因： * 1.Set大部分是无序实现 * 2.Set不允许存放重复元素，所以转换后可能丢失元素。 * */public class ArrayToList { public static void main(String[] args) { String[] array = new String[]{"one","two","three"}; List list = Arrays.asList(array); System.out.println(list); //[one, two, three] /* * 修改该集合元素内容，原数组内容也会发生改变 */ list.set(0,"1"); System.out.println(list); //[1, two, three] //数组第一个元素也变为了"1" System.out.println(Arrays.toString(array)); //[1, two, three] array[2] = "222"; System.out.println(list); //[1, two, 222] System.out.println(Arrays.toString(array)); //[1, two, 222] /* * 对于由数组转换的集合来说，添加元素是不受支持的！ * 所以下面代码会抛异常。 * java.lang.UnsupportedOperationException */ //list.add("four"); //System.out.println(list); //报错 /* * 数组->集合总结： * 1.只能对集合元素进行修改操作，不能删除和增加 * 2.对数组或集合中的元素进行修改时，会影响另一个。 * 3.如果想对集合进行增删操作，可以新new一个集合。 */ /* * 所有的集合都支持一个构造方法，参数要求传入另一个集合。 * 这个构造方法的作用是： * 创建当前集合的同时将给定的集合中的所有元素添加到当前集合中。 * 创建后的新集合的任何操作与原集合无关。对原集合无影响。 */ List list1 = new ArrayList (list); //复制 //list1.addAll(list); list1.add("22"); list1.set(1,"##"); System.out.println(list1); System.out.println(list); }} 1）Collections:集合的工具类
该类提供了若干静态方法，可以方便操作集合。其中sort方法是用来排序List集的。进行自然排序(从小到大)。
代码：
package day05;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Random;/** * Collections:集合的工具类 * 该类提供了若干静态方法，可以方便操作集合。 * 其中sort方法是用来排序List集的。进行自然排序(从小到大) * */public class SortDemo01 { public static void main(String[] args) { List list = new ArrayList (); Random rand = new Random(); for(int i=0;i<10;i++){ list.add(rand.nextInt(100)); } System.out.println(list); /* * sort会对给定的List集合中的元素进行自然排序 * 即：从小到大的顺序 * * 面试题： * Collection与Collections的区别？(或分别说说它们) * * */ Collections.sort(list); System.out.println(list); }} 2）Comparable接口 2.1） Collections的sort方法若希望对集合进行排序，必须保证集合中的元素是可比较大小的。
所以要求元素必须实现Comparable接口，并重写其中的比较大小方法（CompareTo方法），才能进行排序。
2.2）CompareTo方法的作用是使当前对象与给定的对象o进行比较大小。返回值不关注具体值，而是关注取值范围： * 当返回值>0：当前对象比参数对象大
* 当返回值<0：当前对象比参数对象小
* 当返回值=0：两对象相等
2.3）当前元素若希望可以比较大小，需要实现Comparable接口，Comparable支持泛型，而泛型的实际类型就是当前类。意思就是，哪个类实现实现Comparable接口，泛型就是哪个类。
代码演示：
package day05;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Random;public class SortDemo02 { public static void main(String[] args) { List list = new ArrayList (); //Random rand = new Random(); //for(int i=0;i<5;i++){ // list.add(new Point(rand.nextInt(10),rand.nextInt(10))); //} list.add(new Point(1,2)); list.add(new Point(7,9)); list.add(new Point(5,4)); System.out.println(list); //[(1,2), (7,9), (5,4)] /* * Collections的sort方法若希望对集合进行排序，必须保证集合 * 中的元素是可比较大小的。 * 所以要求元素必须实现Comparable接口，并重写其中的 * 比较大小方法，才能进行排序。 */ Collections.sort(list); System.out.println(list); //[(1,2), (5,4), (7,9)] /* * 虽然sort方法可以对集合中的元素进行自然排序 * 但必须要求元素实现Comparable接口，这就出现 * 了由于想使用排序功能而必须改变我们定义的类的 * 内容，这种现象称为“侵入性”。 */ }} 3）Collections的重载sort方法： 要求我们传入两个参数：1：待排序的集合 2：比较器
3.1）通常有两种情况会使用该方法排序集合：
* 1：元素已经实现了Comparable接口，但是比较大小的规则不能满足我们对排序的需求。
* 2：元素没有实现Comparable接口，并且也不希望为了这里排序而强制修改元素，要求其实现接口。
3.2）匿名内部类的方式实现Comparator接口
代码演示：
package day05;import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;/** * Collections的重载sort方法 * */public class SortDemo03 { public static void main(String[] args) { /* * 字符串String实现了Comparable接口 * 排序规则：按照首字母的编码比大小。 */ List list = new ArrayList (); list.add("苍老所"); list.add("小泽老师"); list.add("范老师"); list.add("小老师"); System.out.println(list); //[苍老所, 小泽老师, 范老师, 小老师] /* * Collections的重载sort方法要求我们传入两个参数： * 1：待排序的集合 * 2：比较器 * * 通常有两种情况会使用该方法排序集合： * 1：元素已经实现了Comparable接口，但是比较大小的 * 规则不能满足我们对排序的需求。 * 2：元素没有实现Comparable接口，并且也不希望为了 * 这里排序而强制修改元素，要求其实现接口。 * */ //外部类的方式实现Comparator接口 //MyComparator com = new MyComparator(); //Collections.sort(list,com); //匿名内部类的方式实现Comparator接口 Collections.sort(list,new Comparator (){ @Override public int compare(String o1, String o2) { return o1.length()-o2.length(); } }); /*Comparator comp = new Comparator (){ @Override public int compare(String o1, String o2) { return 0; } };*/ //匿名内部类 System.out.println(list); //[苍老所, 范老师, 小老师, 小泽老师] }}class MyComparator implements Comparator { @Override public int compare(String o1, String o2) { return o1.length()-o2.length(); } } 1）队列（Queue）
保存一组元素，但是对于存取有要求，必须遵循先进先出原则。
1.1）boolean offer(E e)
向队列末尾追加一个元素
1.2）E poll()
从队首获取元素。注意，获取后该元素就从队列中被移除类！ 出队操作。
1.3）E peek()
同样可以获取队首元素，但是与poll不同的是不会将该元素从队列中删除。
具体细节见代码：
package day05;import java.util.LinkedList;import java.util.Queue;/** * 队列 * 保存一组元素，但是对于存取有要求，必须遵循 * 先进先出原则 * * */public class QueueDemo { public static void main(String[] args) { Queue queue = new LinkedList (); /* * boolean offer(E e) * 向队列末尾追加一个元素 */ queue.offer("one"); queue.offer("two"); queue.offer("three"); queue.offer("four"); System.out.println(queue); //[one, two, three, four] /* * E poll() * 从队首获取元素。注意，获取后该元素就从队列 * 中被移除类！ 出队操作 */ String str = queue.poll(); System.out.println(str); //one System.out.println(queue); //[two, three, four] /* * E peek() * 同样可以获取队首元素，但是与poll不同的是 * 不会将该元素从队列中删除。 */ str = queue.peek(); System.out.println(str); //two System.out.println(queue); //[two, three, four] //队列遍历 //1. for(int i=0;i 0;i--){ String str1 = queue.poll(); System.out.println(str1); } System.out.println(queue); //[] //2.--while循环--推荐 while(queue.size()>0){ String str1 = queue.poll(); System.out.println(str1); } System.out.println(queue); //[] }} 2）栈（Stack） 存储一组元素，存取必须遵循先进后出原则。
2.1）Deque（双端队列）是Queue的子接口。
双端队列的特点：队列的两端都可以进出元素。若我们只调用一侧的进出方法，就形成了栈结构。
2.2）void push(E e)
将元素“压入”栈中，入栈操作。新入栈的元素会在栈顶（栈中第一个元素）.
2.3）E pop()
出栈操作，获取栈顶元素，获取后该元素就从栈中被删除了。
2.4）同样可以使用peek()引用栈顶元素，而不做出栈操作。
代码演示：
package day05;import java.util.Deque;import java.util.LinkedList;/** * 栈：存储一组元素，存取必须遵循先进后出原则。 * 通常用来实现有“后退”功能的地方。 * */public class StackDemo { public static void main(String[] args) { /* * Deque是Queue的子接口。 * 双端队列的特点：队列的两端都可以进出元素。 * 若我们只调用一侧的进出方法，就形成了栈结构。 * */ Deque stack = new LinkedList (); /* * void push(E e) * 将元素“压入”栈中，入栈操作。 * 新入栈的元素会在栈顶（栈中第一个元素）. */ stack.push("one"); stack.push("two"); stack.push("three"); System.out.println(stack); //[three, two, one] //stack.offerLast("#"); //System.out.println(stack); /* * E pop() * 出栈操作，获取栈顶元素，获取后该 * 元素就从栈中被删除了。 */ String str = stack.pop(); System.out.println(str); //three System.out.println(stack); //[two, one] /* * 同样可以使用peek()引用栈顶元素， * 而不做出栈操作。 */ str = stack.peek(); System.out.println(str); //two System.out.println(stack); //[two, one] /* * 遍历，和Queue相同 */ while(stack.size()>0){ System.out.println(stack.pop()); } System.out.println(stack); //[] //System.out.println(stack.poll()); //System.out.println(stack.poll()); }} 注：LinkedList实现了List<E>, Deque<E>接口
转载地址：http://vrews.baihongyu.com/