Java—集合（List）

ArrayList类

• 常用方法的使用

package com.fs.test;

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

public class ListDemo {

	public void m1() {

		List<String> list = new ArrayList<String>();

		// 插入顺序与存储顺序相同
		list.add("abc");
		list.add("你好！");
		list.add("123");
		list.add("abc");// 允许重复

		System.out.println("集合大小是：" + list.size());
		System.out.println(list);

		// 移除下标为3的元素
		list.remove(3);
		System.out.println("移除后的元素为：" + list);
		
		//打印下标为1的元素
		System.out.println(list.get(1));
		
		//清空集合
		list.clear();
		System.out.println("清空集合后：" + list);

	}

	public static void main(String[] args) {
		new ListDemo().m1();
	}

}

结果：
集合大小是：4
[abc, 你好！, 123, abc]
移除后的元素为：[abc, 你好！, 123]
你好！
清空集合后：[]

LinkedList类

• LinkedList的使用与ArrayList基本相同。
• 使用双向链表保存元素。
• 要注意指定类型必须使用封装类，例如：Integer。
• 无论使用Arraylist还是LinkedList，结果都一样

package com.fs.test;

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

public class ListDemo {

	public void m2() {
		
		List<Integer> list = new LinkedList<Integer>();
		
		list.add(123456);
		list.add(6789);
		list.add(6789);
		
		System.out.println(list);
		
		list.remove(2);
		System.out.println("移除元素后：" + list);
		
		System.out.println(list.get(1));
		
		list.clear();
		System.out.println("清空元素后：" + list);
		
	}
	
	public static void main(String[] args) {
		new ListDemo().m2();
	}

}

结果：
[123456, 6789, 6789]
移除元素后：[123456, 6789]
6789
清空元素后：[]

总结
接口：List
实现类：
（1）ArrayList：底层是数组，查询，修改元素时较快。
（2）LinkedList：底层是链表，增加、删除元素时较快。
（3）Vector：底层也是数组，线程安全。
（4）使用泛型< E >指定集合中的元素的类型。
（5）可以添加任意类型的数据，用Object表示，如果是基本数据类型，要用封装类表示。
（6）添加元素的顺序与集合中存储数据的顺序相同。
（7）集合可以存在重复的元素。
（8）可以添加null值，但排序时不可使用。

List的排序

• Collections.sort( );——升序排序
• Collections.reverse( );——倒置（将集合元素倒过来，所以不能叫降序）
• Collections.shuffle( );——乱序（每次运行，集合元素顺序都不同）

这里要只提到对自定义类如何进行排序

• 如果要对Student类进行排序，需要Student类实现Comparable接口，并重写compareTo()方法
• 例如：obj1.compareTo(obj2); 如果返回0，表示obj1==obj2；如果返回正整数，表示obj1>obj2；如果返回负整数，表示obj1<obj2。

Student.java文件

package com.fs.test;

public class Student implements Comparable<Student> {
	private int age;
	private String name;

	public Student(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return name + ":" + age;
	}

	//将compaerTo()方法重写，并按两种方式排序。
	@Override
	public int compareTo(Student o) {
		// //按年龄排序
		// int r = this.age - o.age;
		// if (r > 0) {
		// return 1;//升序
		// }else if(r < 0){
		// return -1;
		// }else{
		// return 0;
		// }

		// 按名字排序
		int r = this.name.compareTo(o.name);
		if (r > 0) {
			return -1;// 降序
		} else if (r < 0) {
			return 1;
		} else {
			return 0;
		}
	}

}

ListDemo文件

package com.fs.test;

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

public class ListDemo {

	public void m4() {
		// 对自定义类进行排序
		List<Student> list = new ArrayList<Student>();

		list.add(new Student(55, "zhang"));
		list.add(new Student(30, "li"));
		list.add(new Student(40, "tan"));

		// 排序前
		System.out.println("排序前：" + list);

		// 排序后
		Collections.sort(list);
		System.out.println("排序后：" + list);
	}

	public static void main(String[] args) {
		new ListDemo().m4();
	}

}



结果：
排序前：[zhang:55, li:30, tan:40]
排序后：[zhang:55, tan:40, li:30]

Set的使用

• 元素无序不重复，不可更改元素位置
• 添加顺序和存储顺序无关（元素顺序不可测）
• 元素没有序号，不可通过下标来获取
• 只能通过foreach或Iterator遍历
• 其他参考List

Map的使用

package com.fs.test;

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapDemo {

	// HashMap的使用
	public void m1() {

		Map<String, Object> map = new HashMap<String, Object>();

		// 添加键值对
		map.put("int", 123);
		map.put("char", 'a');
		map.put("String", "abc");
		map.put("obj", 123);

		// 根据键名来移除键值对
		map.remove("obj");
		System.out.println("移除元素之后：" + map);

		// 根据键名来获得值
		System.out.println(map.get("int"));

		map.clear();// 清除集合中的所有键值对
		System.out.println("清空元素后：" + map);

	}

	// TreeMap的使用：对基本数据类型排序
	public void m2() {
		Map<Integer, Object> map = new TreeMap<Integer, Object>();

		map.put(2, "abc");
		map.put(5, "ddd");
		map.put(4, true);
		map.put(6, 999);
		map.put(1, 1.6f);

		System.out.println(map);

	}

	public static void main(String[] args) {
//		new MapDemo().m1();
		new MapDemo().m2();
	}

}


结果：
{1=1.6, 2=abc, 4=true, 5=ddd, 6=999}

Map的遍历

• foreach遍历和Iterator遍历

package com.fs.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	public void m1() {
		Map<String, Object> map = new HashMap<String, Object>();

		map.put("int", 123);
		map.put("char", 'a');
		map.put("String", "abc");
		map.put("obj", 123);

		// foreach遍历
		Set<String> set = map.keySet();//得到一个Set集合，这个集合装了所有的键名
		for (String key : set) {
			System.out.println(key + ":" + map.get(key));
		}
		
		System.out.println("-------------------------------");

		// Iterator遍历
		Set<String> set2 = map.keySet();//得到一个Set集合，这个集合装了所有的键名
		Iterator<String> it = set2.iterator();//通过Set集合得到一个Iterator对象
		while(it.hasNext()){//判断下一个键名是否存在
			String key= it.next();//取出键名
			System.out.println(key + ":" +map.get(key));//根据键名取出值
			
		}

	}

	public static void main(String[] args) {
		new MapDemo().m1();

	}

}

结果：
obj:123
char:a
String:abc
int:123
-------------------------------
obj:123
char:a
String:abc
int:123