Java高级编程07(集合框架之List集合)

最新推荐文章于 2024-05-01 19:10:24 发布

云破丶日出

最新推荐文章于 2024-05-01 19:10:24 发布

阅读量359

点赞数 5

分类专栏： JavaSE高级篇文章标签： 1024程序员节 java list

本文链接：https://blog.csdn.net/sinat_38326464/article/details/120938425

版权

JavaSE高级篇专栏收录该内容

7 篇文章 0 订阅

订阅专栏

List集合

java.util.List接口,继承自Collection。
         List集合是可重复集,并且有序,提供了一套可以通过下标操作元素的方法。
常用实现类:
         java.util.ArrayList:内部使用数组实现,查询性能更好。
         java.util.LinkedList:内部使用链表实现,首尾增删元素性能更好.
List集合常见方法
         1、get()与set()

package com.test.list;
import java.util.ArrayList;
import java.util.List;
/**
* List集合
* List是Collection下面常见的一类集合。
* java.util.List接口是所有List的接口，它继承自Collection。
* 常见的实现类:
* java.util.ArrayList:内部由数组实现，查询性能更好。
* java.util.LinkedList:内部由链表实现，增删性能更好。
*
* List集合的特点是:可以存放重复元素，并且有序。其提供了一套可以通过下标
* 操作元素的方法。
*/
public class ListDemo {
		public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		// List<String> list = new LinkedList<>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		list.add("five");
		/*
		E get(int index)
		获取指定下标对应的元素
		*/
		//获取第三个元素
		String e = list.get(2);
		System.out.println(e);
		for(int i=0;i<list.size();i++){
		e = list.get(i);
		System.out.println(e);
		}
		/*
		E set(int index,E e)
		将给定元素设置到指定位置，返回值为该位置原有的元素。
		替换元素操作
		*/
		//[one,six,three,four,five]
		String old = list.set(1,"six");
		System.out.println(list);
		System.out.println("被替换的元素是:"+old);
		}
}

2、重载的add()和remove()

package com.test.list;
import java.util.ArrayList;
import java.util.List;
/**
* List集合提供了一对重载的add,remove方法
*/
public class ListDemo2 {
	public static void main(String[] args) {
	List<String> list = new ArrayList<>();
	list.add("one");
	list.add("two");
	list.add("three");
	list.add("four");
	list.add("five");
	System.out.println(list);
	/*
	void add(int index,E e)
	将给定元素插入到指定位置
	*/
	//[one,two,six,three,four,five]
	list.add(2,"six");
	System.out.println(list);
	/*
	E remove(int index)
	删除并返回指定位置上的元素
	*/
	//[one,six,three,four,five]
	String e = list.remove(1);
	System.out.println(list);
	System.out.println("被删除的元素:"+e);
	}
}

3、subList()方法

package com.test.list;
import java.util.ArrayList;
import java.util.List;
/**
* List subList(int start,int end)
* 获取当前集合中指定范围内的子集。两个参数为开始与结束的下标(含头不含尾)
*/
public class ListDemo3 {
	public static void main(String[] args) {
	List<Integer> list = new ArrayList<>();
	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++){
		subList.set(i,subList.get(i) * 10);
	}
	//[30,40,50,60,70]
	System.out.println(subList);
	/*
	对子集元素的操作就是对原集合对应元素的操作
	*/
	System.out.println(list);
	//删除list集合中的2-8
	list.subList(2,9).clear();
	System.out.println(list);
	}
}

集合与数组的转换

1、集合转换为数组
Collection提供了一个方法:toArray,可以将当前集合转换为一个数组

package com.test.list;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 集合转换为数组
* Collection提供了方法toArray可以将当前集合转换为一个数组
*/
public class CollectionToArrayDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		list.add("five");
		System.out.println(list);
		// Object[] array = list.toArray();
		/*
		重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组
		后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，
		则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并
		将集合元素存入后返回。
		*/
		String[] array = list.toArray(new String[list.size()]);
		System.out.println(array.length);
		System.out.println(Arrays.toString(array));
	}
}

2、数组转换为List集合
数组的工具类Arrays提供了一个静态方法asList(),可以将一个数组转换为一个List集合

package com.test.list;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 数组转换为List集合
* 数组的工具类Arrays提供了一个静态方法asList，可以将数组转换为一个List集合。
*/
public class ArrayToListDemo {
	public static void main(String[] args) {
	String[] array = {"one","two","three","four","five"};
	System.out.println(Arrays.toString(array));
	List<String> list = Arrays.asList(array);
	System.out.println(list);
	list.set(1,"six");
	System.out.println(list);
	//数组跟着改变了。注意:对数组转换的集合进行元素操作就是对原数组对应的操作
	System.out.println(Arrays.toString(array));
	/*
	由于数组是定长的，因此对该集合进行增删元素的操作是不支持的，会抛出
	异常:java.lang.UnsupportedOperationException
	*/
	// list.add("seven");
	/*
	若希望对集合进行增删操作，则需要自行创建一个集合，然后将该集合元素
	导入。
	*/
	// List<String> list2 = new ArrayList<>();
	// list2.addAll(list);
	/*
	所有的集合都支持一个参数为Collection的构造方法，作用是在创建当前
	集合的同时包含给定集合中的所有元素
	*/
	List<String> list2 = new ArrayList<>(list);
	System.out.println("list2:"+list2);
	list2.add("seven");
	System.out.println("list2:"+list2);
	}
}

3、集合的排序
java.util.Collections类
Collections是集合的工具类,里面定义了很多静态方法用于操作集合.
Collections.sort(List list)方法，可以对List集合进行自然排序(从小到大)

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* 集合的排序
* 集合的工具类:java.util.Collections提供了一个静态方法sort,可以对List集合
* 进行自然排序
*/
public class SortListDemo1 {
	public static void main(String[] args) {
	List<Integer> list = new ArrayList<>();
	Random random = new Random();
	for(int i=0;i<10;i++){
		list.add(random.nextInt(100));
	}
	System.out.println(list);
	Collections.sort(list);
	System.out.println(list);
	}
}

4、排序自定义类型元素

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
	public static void main(String[] args) {
		List<Point> list = new ArrayList<>();
		list.add(new Point(3,5));
		list.add(new Point(7,9));
		list.add(new Point(1,1));
		list.add(new Point(8,3));
		list.add(new Point(2,6));
		System.out.println(list);
		/*
		编译不通过的原因:
		Collections.sort(List list)该方法要求集合中的元素类型必须实现接口:
		Comparable,该接口中有一个抽象方法compareTo,这个方法用来定义元素之间比较
		大小的规则.所以只有实现了该接口的元素才能利用这个方法比较出大小进而实现排
		序
		操作.
		*/
		Collections.sort(list);//编译不通过 compare比较 comparable可以比较的
		System.out.println(list);
	}
}

实际开发中,我们并不会让我们自己定义的类(如果该类作为集合元素使用)去实现Comparable接口,因为这对我们的程序有侵入性。侵入性：当我们调用某个API功能时，其要求我们为其修改其他额外的代码，这个现象就是侵入性。侵入性越强的API越不利于程序的后期可维护性，应当尽量避免。

5、重载的Collections.sort(List list,Comparator c)方法

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
	public static void main(String[] args) {
		List<Point> list = new ArrayList<>();
		list.add(new Point(3,5));
		list.add(new Point(7,9));
		list.add(new Point(1,1));
		list.add(new Point(8,3));
		list.add(new Point(2,6));
		System.out.println(list);
		/*
		编译不通过的原因:
		Collections.sort(List list)该方法要求集合中的元素类型必须实现接口:
		Comparable,该接口中有一个抽象方法compareTo,这个方法用来定义元素之间比较
		大小的规则.所以只有实现了该接口的元素才能利用这个方法比较出大小进而实现排
		序
		操作.
		当我们调用某个API时,它反过来要求我们为其修改其他额外的代码时就是侵入性.
		侵入性不利于程序后期的维护,应当在实际开发中尽量避免.
		*/
		// Collections.sort(list);//编译不通过 compare比较 comparable可以比较的
		/*
		Collections.sort(List list,Comparator c)
		重载的sort方法要求我们再传入一个Comparator"比较器",该比较器用来为集合元
		素
		临时定义一种比较规则,从而将List集合中的元素通过该比较器比较大小后进行排序.
		Comparator是一个接口,实际应用中我们需要实现该接口为集合元素提供比较规则.
		*/
		Comparator<Point> c = new Comparator<Point>() {
		/**
		* compare方法用来定义两个参数o1,o2的大小关系
		* 返回值用来表示o1与o2的大小关系
		* 当返回值>0时,应当表示的含义是o1>o2
		* 当返回值<0时,表示o1<o2
		* 当返回值=0时,表示o1与o2相等
		*/
		public int compare(Point o1, Point o2) {
			int olen1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
			int olen2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
			return olen1-olen2;
		}
	};
	Collections.sort(list,c);
	System.out.println(list);
	}
}

最终没有侵入性的写法

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
	public static void main(String[] args) {
		List<Point> list = new ArrayList<>();
		list.add(new Point(3,5));
		list.add(new Point(7,9));
		list.add(new Point(1,1));
		list.add(new Point(8,3));
		list.add(new Point(2,6));
		System.out.println(list);
		/*
		编译不通过的原因:
		Collections.sort(List list)该方法要求集合中的元素类型必须实现接口:
		Comparable,该接口中有一个抽象方法compareTo,这个方法用来定义元素之间比较
		大小的规则.所以只有实现了该接口的元素才能利用这个方法比较出大小进而实现排
		序
		操作.
		当我们调用某个API时,它反过来要求我们为其修改其他额外的代码时就是侵入性.
		侵入性不利于程序后期的维护,应当在实际开发中尽量避免.
		*/
		// Collections.sort(list);//编译不通过 compare比较 comparable可以比较的
		/*
		Collections.sort(List list,Comparator c)
		重载的sort方法要求我们再传入一个Comparator"比较器",该比较器用来为集合元
		素
		临时定义一种比较规则,从而将List集合中的元素通过该比较器比较大小后进行排序.
		Comparator是一个接口,实际应用中我们需要实现该接口为集合元素提供比较规则.
		*/
		// Comparator<Point> c = new Comparator<Point>() {
		// /**
		// * compare方法用来定义两个参数o1,o2的大小关系
		// * 返回值用来表示o1与o2的大小关系
		// * 当返回值>0时,应当表示的含义是o1>o2
		// * 当返回值<0时,表示o1<o2
		// * 当返回值=0时,表示o1与o2相等
		// */
		// public int compare(Point o1, Point o2) {
		// int olen1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
		// int olen2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
		// return olen1-olen2;
		// }
		// };
		// Collections.sort(list,c);
		Collections.sort(list,new Comparator<Point>() {
		public int compare(Point o1, Point o2) {
		int olen1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
		int olen2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
		return olen1-olen2;
		}
	});
	System.out.println(list);
	}
}

案例练习：
创建Student类，创建集合将Student对象加入集合，按学号对学生信息进行排序。

创建Student类

package com.scy.array;
public class Student{
		//属性
		public int  id;
		public String name;
		public String sex;
		public int  age;
	
		//getter  setter
		public int getId() {
			return id;
		}
		public void setId(int id) {
			this.id = id;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public String getSex() {
			return sex;
		}
		public void setSex(String sex) {
			this.sex = sex;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		//toString
		@Override
		public String toString() {
			return "Student [id=" + id + ", name=" + name + ", sex=" + sex + ", age=" + age + "]";
		}
		//有参
		public Student(int id, String name, String sex, int age) {
			super();
			this.id = id;
			this.name = name;
			this.sex = sex;
			this.age = age;
		}
		//无参
		public Student() {
			super();
		}
	}

Student类的学号排序：

package com.scy.homework;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class HomeWorkDemo4 {
	public static void main(String[] args) {

		//创建集合
		List<Student> list = new ArrayList<>();

		//创建Student对象
		Student stu1 = new Student(202001,"张三","男",12);
		Student stu2 = new Student(202005,"李四","女",45);
		Student stu3 = new Student(202003,"王五","男",18);
		Student stu4 = new Student(202004,"马六","男",22);
		Student stu5 = new Student(202002,"赵一","男",32);

		//将stu对象添加到集合中
		list.add(stu1);
		list.add(stu2);
		list.add(stu3);
		list.add(stu4);
		list.add(stu5);
		for (Student student : list) {
			System.out.println(student);
		}
		
		System.out.println("=============按学号排序后=============");
		
		/**
		 * 按照Student类的学号进行排序
		 */
		Collections.sort(list,new Comparator<Student>() {

			@Override
			public int compare(Student stu, Student student) {
				//定义返回值 大小关系
				int i=0;
				//获取第一个对象的id
				int id1 = stu.getId();
				//获取第二个对象的id
				int id2 = student.getId();
				//第一个大于第二个
				if (id1>id2) {
					i=1;
				}else if(id1==id2){//第一个等于第二个
					i=0;
				}else if(id1<id2){//第一个小于第二个
					i=-1;
				}
				return i;
			}
		});
		for (Student student : list) {
			System.out.println(student);
		}
	}
}

排序字符串
java中提供的类,如:String,包装类都实现了Comparable接口,但有时候这些比较规则不能满足我们的排序需求时,同样可以临时提供一种比较规则来进行排序.

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortListDemo3 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		// list.add("Tom");
		// list.add("jackson");
		// list.add("rose");
		// list.add("jill");
		// list.add("ada");
		// list.add("hanmeimei");
		// list.add("lilei");
		// list.add("hongtaoliu");
		// list.add("Jerry");
		list.add("波多老师");
		list.add("小泽老师");
		list.add("苍老师");
		System.out.println(list);
		//按照字符多少排序
		// Collections.sort(list);
		// Collections.sort(list, new Comparator<String>() {
		// public int compare(String o1, String o2) {
		 return o1.length()-o2.length();
		// return o2.length()-o1.length();//反过来减就是降序
		// }
		// });
		Collections.sort(list,(o1,o2)->o2.length()-o1.length());
		System.out.println(list);
	}
}

云破丶日出

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java高级编程07(集合框架之List集合)

List集合java.util.List接口,继承自Collection。         List集合是可重复集,并且有序,提供了一套可以通过下标操作元素的方法。常用实现类:         java.util.ArrayList:内部使用数组实现,查询性能更好。    &nbs
复制链接

扫一扫