34Java集合-----List接口

List接口

ArrayList和LinkedList

• List接口是Collection的子接口，用于定义线性表数据结构。可以将：List理解为存放对象的数组，只不过其元素个数可以动态的增加或减少
• List接口的两个常见实现类为ArrayList和LinkedList，分别用动态数组和链表的方式实现了List接口
• 可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别。ArrList更适合于随机访问LinkdList更适合于插入和删除。在性能要求不是特别苛刻的情形下可以忽略这个差别
  

get和set

• List除了继承Collection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最常用的就是基于下标的个体和set方法

package day04;

/**
 * Java.util.List
 * 可重复集，并且有序
 * 特点是可以根据下标操作元素
 * 常用实现类：
 * ArrayList：使用数组实现，查询更快
 * LinkKedList：使用链表实现，增删更快（首尾增删效果明显）
 * @author Administrator
 *
 */
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo1 {
	public static void main(String[] args){
		//java.util.List
		/*
		 * E set(int index, E e)
		 * 将给定的的元素设置到指定位置上，
		 * 返回值为原位置被替换的元素
		 */
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		//one two three four
		System.out.println(list);
		//one 2 three four
		String old = list.set(1, "2");
		System.out.println("被替换的元素:"+old);
		System.out.println(list);
		
		/*
		 *
		 * set的作用不是添加新元素，而是替换操作
		 * 所以下标不能超过集合要求的范围
		 */
//		list.set(4, "4");这样做下标越界
		
		/**
		 * E get(int index)
		 * 获取给定下标对应的元素
		 */
		//获取第三个元素
		String str = list.get(2);
		System.out.println(str);
		//传统循环遍历List集合
		for(int i=0;i<list.size();i++) {
			str = list.get(i);
			System.out.println(str);
		}
		

		
	}
}

插入和删除

package day04;

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

/**
 * List集合提供了一对重载的add,remove方法
 * void add(int index, E e)
 * 将给定元素插入到指定位置
 * E remove(int index)
 * 从集合中删除指定位置的元素，并将其返回
 * @author Administrator
 *  */
public class ListDemo2 {
	public static void main(String[] args){
		List<String> list	
			= new ArrayList<String>();
		//Collection中的add.向集合中追加新元素
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		//one two three four
		System.out.println(list);
		//List的add方法，通常是插入新元素
		//one 2 two three four
		list.add(1,"2");
		System.out.println(list);
		
		/*
		 * 删除给定位置的元素---one 2  three four
		 */
		String str = list.remove(2);
		System.out.println("被删除的元素是:"+str);
		System.out.println(list);
	}
}

subList

• List的subList方法用于获取子List
• 需要注意的是，subList获取的List与原List占有相同的存储空间，对子List的操作会影响原List
• List<E> subList(int fromIndex,int toIndex)
• fromIndex和toIndex是截取子List的首尾下标（前包括后不包括）

package day04;
/**
 * 获取子集 subList(int start,int end)
 * 获取当前集合中指定范围内的子集。同样
 * 含头不含尾
 * @author Administrator
 *
 */

import java.util.ArrayList;
import java.util.List;
public class ListDemo3 {
	public static void main(String[] args){
			List<Integer> list= new ArrayList<Integer>();
			
			//[0,1,2,3,4,5,6,7,8,9]
			for(int i=0;i<10;i++){
				list.add(i);
			}
			System.out.println(list);
			
			//获取3-7
			List<Integer> subList =	list.subList(3, 8);
			System.out.println(subList);
			
			//对子集中每个元素扩大10倍
			for(int i=0;i<subList.size();i++){
				int num = subList.get(i);
				num = num * 10;
				subList.set(i, num);
			}
			/*
			 * 当我们通过子集修改元素，会影响原
			 * 集合
			 */     
			System.out.println(subList);
			System.out.println(list);	
			//删除集合2-8的元素
			list.subList(2, 9).clear();
			System.out.println(list);
	}
}

LIst转换为数组

• List的to Array方法用于将集合转换为数组。但实际上该方法是在Collection中定义的，所以所有的集合都具备这个功能
• 其有两个方法：Object[] toArray() <T>T[] toArray(T[] a)其中第二个方法时比较常用的，我们可以传入一个指定类型的数组，该数组的元素类型应与集合的元素类型一致。返回值则是转换后的数组，该数组会保存集合中所有的元素

package day04;
/**
 * List转换为数组
 * @author Administrator
 *
 */
import java.util.ArrayList;
import java.util.Collection;


public class ListDemo4 {
	public static void main(String[] args){
		Collection<String> c = new ArrayList<String>();
		c.add("one");
		c.add("two");
        c.add("three");
		c.add("four");
		/**
		 * 集合提供了一个方法toArray，可以
		 * 将当前集合转换为数组
		 */
		//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);
		}
		
	}
}

数组转换为List集合

package day04;
/**
 * 数组转换为List集合
 * 需要注意，转换只能转换为List集合
 * 使用的是数组的工具类Arrays的静态方法asList
 * 只能转换为List集合的主要原因是：Set不能存放重复元素
 * 所以转换为Set集合可能出现丢失元素的情况
 * @author Administrator
 *
 */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


public class ListDemo5 {
	public static void main(String[] args) {
		String[] array = {"a","b","c","d"};
		List<String> list = Arrays.asList(array);	
		System.out.println(list);
		/**
		 * 向集合中添加一个元素
		 * 
		 * 实际上下面的代码会抛出异常。原因在于，该集合
		 * 是由数组转换过来的，那么该集合就表示原来的数组，
		 * 所以对集合的操作就是丢=对数组的操作。那么添加元素
		 * 会导致原数组的扩容，那么就不能表示原来的数组了。
		 * 所以不允许向该集合添加新元素
		 */
		//list.add("e");
		//System.out.println(list);
		//修改集合元素，数组元素也会改变
		list.set(3, "e");
		System.out.println(list);
		//输出数组元素
		System.out.println(
				Arrays.toString(array));
		/**
		 * 若希望增删元素，需要创建另一个集合
		 */
		/*
		 * 所有的集合实现类都支持一个构造方法
		 * 该方法可以传入一个Collection，
		 * 那么该构造方法创建出来的集合默认
		 * 就添加了给定集合中的所有元素
		 * 这样的构造方法叫做复制构造器
		 */
		//List<String> list2 = new ArrayList<String>();
		//list2.addAll(list);
		List<String> list2 = new ArrayList<String>(list);
		list2.add("e");
		System.out.println(list2);
	}
}

排序

package day04;
/**
 * List集合的排序
 * 对Set集合排序通常是无意义的
 * 排序集合使用的是集合的工具类Collections
 * 的静态方法sort
 * 排序仅能对List集合进行。因为Set部分实现类是无序的
 * @author Administrator
 *
 */
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class ListDemo6 {
	public static void main(String[] args){
		List<Integer> list
			= new ArrayList<Integer>();
		/*
		 * 生成10个随机数放入集合
		 */
		Random random = new Random();
		for(int i=0;i<10;i++){
			list.add(random.nextInt(100));
		}
		System.out.println(list);
		/*
		 * Collections.sort方法
		 * 会对集合进行自然排序(由小至大)
		 */
		Collections.sort(list);
		System.out.println(list);
	}
}

package day05;
/**
 * 该类用于作为集合的元素
 * @author 李玉
 *
 */
public class Point implements Comparable<Point>{
	private int x;
	private int y;
	public Point(int i, int j) {
		x=i;
		y=j;
	}
	@Override
	public String toString() {
		return "Point [x=" + x + ", 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;
	}
	/**
	 * 当实现了Comparable接口后，需要重写下面的方法
	 * 该方法的作用是定义当前对象与给定参数对象比较大小的规则
	 * 返回值为一个int值，该值表示大小关习，它不关注具体的取值是多少
	 * 而关注的是取值范围
	 * 当返回值大于0时，当前对象比参数对象大
	 * 当返回值小于0时，当前对象比参数对象小
	 * 当返回值等于0时，两个对象相等
	 * 
	 */
	@Override
	public int compareTo(Point 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 day05;

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

/**
 * 排序自定义类型元素的集合
 * @author 
 *
 */
public class SortListDemo1 {
       public static void main(String[] args) {
    	   List<Point> list = new ArrayList<Point>();
    	   
    	   list.add(new Point(4,2));
    	   list.add(new Point(2,3));
    	   list.add(new Point(1,4));
    	   list.add(new Point(6,7));
    	   list.add(new Point(9,3));
    	   list.add(new Point(8,1));
    	   
    	   System.out.println(list);
    	   /**
    	    * sort方法要求集合元素必须实现Comparable
    	    * 接口，该接口用于规定实现类是可以比较的
    	    * 其中有一个抽象方法是用来定义比较大小的规则
    	    * 
    	    * 我们想使用sort方法排序集合，但是该方法
    	    * 要求我们的集合元素必须实现Comparable接口并且
    	    * 定义比较规则，这种我们想使用某个功能，
    	    * 而它要求我们修改程序的
    	    * 现象称为“侵入性”
    	    * 修改的代码越多，侵入性越强，越不利于程序的扩展
    	    */
    	   Collections.sort(list);
    	   System.out.println(list);
	
    }
}

package day05;

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

public class SortListDemo2 {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("范老师");
		list.add("苍老师");
		list.add("小泽老师");
		
		System.out.println(list);
		MyComparator com = new MyComparator();
		/**
		 * 重载的sort方法要求传入一个额外的比较器
		 * 该方法不再要求集合元素必须实现Comparable
		 * 接口，并且也不再使用集合元素自身的比较规则
		 * 排序了，而是根据给定的这个额外的比较器的比较
		 * 规则对集合元素进行排序
		 * 实际开发中也推荐使用这种排序方式排序集合元素
		 * 若集合元素是自定义的、
		 * 创建比较器也推荐使用匿名内部类的形式
		 */
		Collections.sort(list);
		//匿名内部类形式创建
		Comparator<String> com1 = new Comparator<String>() {
			
			public int compare(String o1,String o2) {
				return o1.length()-o2.length();
				
			}

		};
		MyComparator com11
		= new MyComparator();
		Collections.sort(list,com11);
		System.out.println(list);
		
	}

}
/**
 * 定义一个额外的比较器
 * @author 李玉
 *
 */
class MyComparator implements Comparator<String> {
	/**
	 * 该方法用来定义o1和o2的比较
	 * 若返回值大于0：o1大于o2；
	 * 若返回值小于0：o1<o2;
	 * 若返回值=0:两个对象相等
	 * @param o1
	 * @param o2
	 * @return
	 */
	@Override
	public int compare(String o1, String o2) {
		// 哪个字符串的字符多哪个字符串大
		return o1.length() - o2.length();
	}

}