java 集合_java的集合 csdn-CSDN博客

本文链接：https://blog.csdn.net/jiuliangtan/article/details/78847919

泛型

优点:1,增加代码安全性

2,省去强制转换的麻烦

3,泛形可以将运行时的错误在编译时发现

数组保存字符串泛型实例

ArrayList<String> list = new ArrayList<String>();
		list.add("B");
		list.add("a");
		list.add("c");
		list.add("s");
		ListIterator<String> listiterator = list.listIterator();
		//正相遍历
		while(listiterator.hasNext()) {
			String next = listiterator.next();
			System.out.println(next);
		}
		//逆向遍历
		while(listiterator.hasPrevious()) {
			String previous = listiterator.previous();
			System.out.println(previous);
		}

在jdk 1.7 菱形泛型
//后面的泛型可以不写,如不写默认与声明泛型一致,写的话前后须一致

//遍历int 数组的方法
//	public static void print (int[] array) {
//		
//	}
	//int...相当于数组int[]
	//下列方法还能不能添加int 类型的参数
	//注意,如果多参数,那么int...放到最后
	public static void print (int x , int ... num) {
		for (int i = 0; i < num.length; i++) {
			System.out.println(i);
		}
		
	}

数组转list可使用方法aslist

int[] array = {1,2,3,4,5};
//		List<int[]> asList = Arrays.asList(array);
//		System.out.println(asList);
//				//直接使用基本数据类型包装类
//		Interger[] newArray = {1,2,3,4,5};
//		List<Integer> asList2 = Arrays.asList(newArray);

这里把整个数组当做一个元素存到集合中

这时因为集合中只能保存对象类型,致使数组无法自动装箱

所以数组转化为集合,不能对其做增加或删除的操作

但可以使用集合中的其他方法

泛型通配符

? extends E ?是子类 E是父类

向下限定,只允许往下继承,如子类,zizi类

? super E 向上继承

集合的三种删除方式

public static void fun1() {
		//遍历集合
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("s");
	
		for (int i = 0; i < list.size(); i++) {
//			如果集合中有b,删除
			if(list.get(i).equals("b")) {
				//i-- 保证每次删除后,角标能够回调,为不会少元素
				//保证删除后依然遍历数组每一个元素
				list.remove(i--);
			}
			System.out.println(list.get(i));              
		}
	}

使用迭代器删除

//迭代器删除
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("s");
	    Iterator<String> iterator = list.iterator();
		while (iterator.hasNext()) {
			String next = iterator.next();
			if(next.equals("b")) {
				//这里调用迭代器方法remove删除,否则会发生并发报错
				//如果要添加元素 ,使用listiterator迭代
				
				iterator.remove();
			}
			
		}
	}

ist<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("s");
		//遍历
		//冒号后是你要遍历的容器
		//冒号前是你要遍历的容器中每一个元素
		//增强for循环底层是用迭代器实现的
		//一般只用来打印,无法作删除的操作
		for(String str:list) {
			
			System.out.println(str);
		}
	}

集合的排序

//创建一个数组,保存5个学生,把学生按年龄排序

核心就是比较和交换,可使用冒泡排序和选择排序

	ArrayList<Student> list = new ArrayList<>();
		list.add(new Student("ss",14));
		list.add(new Student("dd",12));
		list.add(new Student("gg",13));
		list.add(new Student("mm",11));
		list.add(new Student("xx",17));
		for (int i = 0; i < list.size()-1; i++) {
			for (int j = 0; j < list.size()-1-i; j++) {
				//核心比较和交换
				//取出要比较的两个学生
				Student s1 = list.get(j);
				Student s2 = list.get(j+1);
				if(s1.getAge() < s2.getAge()) {
					Student temp = s1;
					list.set(j,s2);
					list.set(j+1, temp);
					Collections.swap(list,j,j+1);
				}
				
				
			}
			
		}
		System.out.println(list);
	}

按姓名排序

		
		list1.add(new Student("ss",14));
		list1.add(new Student("dd",12));
		list1.add(new Student("gg",13));
		list1.add(new Student("mm",11));
		list1.add(new Student("xx",17));
		for (int i = 0; i < list1.size()-1; i++) {
			for (int j = 0; j < list1.size()-1-i; j++) {
				Student s1 = list1.get(j);
				Student s2 = list1.get(j+1);
				if(s1.getName().compareTo(s2.getName())> 0) {
					Student temp = s1;
					list1.set(j,s2);
					list1.set(j+1, temp);
				}
			}	
			}

也可以选择调用系统的方法

collections 的 sort() 方法

此方法是系统提供的排序方法

但是缺失排序规则

系统提供了写排序规则的接口,由你去实现此接口(回调思想)

数组里放的什么对象,就由该对象去实现这个接口

使用collections 中sort() 实现排序步骤

1,让集合中被排序对象的类,去实现接口 Comparable

2,实现接口中的抽象方法(方法重写)

3,编写排序规则

4,调用Collection.sort()测试.

		ArrayList<Student> list = new ArrayList<>();
		list.add(new Student("ss",14));
		list.add(new Student("dd",12));
		list.add(new Student("gg",13));
		list.add(new Student("mm",11));
		list.add(new Student("xx",17));
		Collections.sort(list);

对象实现接口部分

public class Student extends Person  implements Comparable<Student>{
	public Student() {
	}
	public Student(String name, int age) {
		// TODO Auto-generated constructor stub
		super(name,age);
	}
	//Comparable接口中抽象方法
	//这个有你来写排序规则
	@Override
	public int compareTo(Student o) {
		
			//返回0,两个值相等
			//返回正数,前面的大
			//返回副数,后面的大
			
			return this.getAge() - o.getAge();
			//按学生姓名牌
			//这个compareTo是字符串的方法
			//return this.getName().compareTo(o.getName());
		}
	}

集合的嵌套

public static void main(String[] args) {
		//一个java学科,有两个班,每个班里有俩学生
		ArrayList<ArrayList<Student>>subjects = 
				new ArrayList<>();
		ArrayList<Student> classes1 = new ArrayList<>();
		classes1.add(new Student("sdf",23));
		ArrayList<Student> classes2 = new ArrayList<>();
		classes2.add(new Student("sdfs",22));
		subjects.add(classes1);
		subjects.add(classes2);
		for(ArrayList<Student> classes: subjects) {
			for(Student student: classes) {
				System.out.println(student);
			}
		}
					
	
		
				
				
	}