【JavaSE】day05_List集合_List排序_队列和栈

【JavaSE】day05_List集合_List排序_队列和栈

1.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<String> list = new ArrayList<String>();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<list.size();i++){ //size()来获取容器元素个数str = list.get(i);System.out.println(str);}//2.Iterator<String> 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<String> list = new LinkedList<String>();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); //threeSystem.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<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 subList(int start,int end) * 获取当前集合中给定范围内的部分子集 */List<Integer> subList = list.subList(3,8);System.out.println(subList); //[3, 4, 5, 6, 7]//将子集中的每个元素扩大10倍for(int i=0;i<subList.size();i++){/*int n = subList.get(i);n = n*10;subList.set(i,n);*/subList.set(i,subList.get(i)*10);}System.out.println(subList); //[30, 40, 50, 60, 70]/* * 对子集的任何操作都会影响原集合。 */System.out.println(list); //[0, 1, 2, 30, 40, 50, 60, 70, 8, 9]//清空子集，原集合中该部分内容也被删除。//通过清空子集来快速删除原集合的指定内容。subList.clear();System.out.println(list); //[0, 1, 2, 8, 9]}}

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<String> c = new ArrayList<String>();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<String> 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<String> list1 = new ArrayList<String>(list); //复制//list1.addAll(list);list1.add("22");list1.set(1,"##");System.out.println(list1);System.out.println(list);}}

2.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<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);/* * 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<Point> list = new ArrayList<Point>();//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<String> list = new ArrayList<String>();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<String>(){@Overridepublic int compare(String o1, String o2) {return o1.length()-o2.length();}});/*Comparator<String> comp = new Comparator<String>(){@Overridepublic int compare(String o1, String o2) {return 0;}};*/   //匿名内部类System.out.println(list); //[苍老所, 范老师, 小老师, 小泽老师]}}class MyComparator implements Comparator<String>{@Overridepublic int compare(String o1, String o2) {return o1.length()-o2.length();}}

3.队列和栈

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<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); //[one, two, three, four]/* * E poll() * 从队首获取元素。注意，获取后该元素就从队列 * 中被移除类！ 出队操作 */String str = queue.poll();System.out.println(str); //oneSystem.out.println(queue); //[two, three, four]/* * E peek() * 同样可以获取队首元素，但是与poll不同的是 * 不会将该元素从队列中删除。 */str = queue.peek();System.out.println(str); //twoSystem.out.println(queue); //[two, three, four]//队列遍历//1.for(int i=0;i<queue.size();i++){String str1 = queue.poll();System.out.println(str1);}//原因：每执行一次for循环，queue.size()就会减一System.out.println(queue); //[four]//1.2 改进--倒着for(int i=queue.size();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<String> stack = new LinkedList<String>();/* * 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); //threeSystem.out.println(stack); //[two, one]/* * 同样可以使用peek()引用栈顶元素， * 而不做出栈操作。 */str = stack.peek();System.out.println(str); //twoSystem.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>接口