JAVA学习代码——集合

集合的种类

集合的接口以及实现类

三种常用集合的区别：有序，无序，元素类型

集合的遍历

集合：Set_List.java

package 集合;

//import java.util.ArrayList;
//import java.util.HashSet;
//import java.util.Iterator;
//import java.util.List;
//import java.util.Set;
import java.util.*;

/**
 * List、Map、Set三个接口，存取元素时，各有什么特点？
 * http://blog.sina.com.cn/s/blog_49b4a1f10100ota8.html
 * 
 * 集合是什么：集合是可以存放其他对象的特殊对象，是存放对象的容器
 * 	1.set
 *  2.list
 *  3.map：
 * 集合：有接口（Collection、子接口List、Set）、时实现类（Set->HashList、List->ArrayList/LinkedList/
 * Vector）、算 法（add、remove...）
 * 
 * 1.插队，即调用add(int index,Obje)方法，将元素放入指定位置 ：add(1，s1) 
 * 2.set没有顺序，存入和输出都无序
 * 3.list有序
 * 4.集合下标也是从0开始
 * 5.集合的长度用size()表示，例：list.size()
 * 
 * 1 java中的length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了length这个属性.
 * 2 java中的length()方法是针对字符串String说的,如果想看这个字符串的长度则用到length()这个方法.
 * 3.java中的size()方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!
 * 
 */
public class Set_List {

	public static void main(String[] args) {
		// 调用Student中Student(String name, int age)方法
		Student s1 = new Student("zhangsan", 15);
		Student s2 = new Student("lisi", 16);
		Student s3 = new Student("wangwu", 17);
		Student[] stu1 = new Student[3];// 定义数组是必须指定长度，不可变更
		stu1[0] = s1;
		stu1[1] = s2;
		stu1[2] = s3;
		// 利用for循环输出数组元素
		System.out.println("打印===stu[]===数组元素");
		for (int i = 0; i < 3; i++) {
			System.out.println(stu1[i]);
		}

		// 创建学生数组，并赋值
		// Student []stu0={new Student("zhangsan",15),new Student("lisi",16),new
		// Student("wangwu",17)};

		// 1、new一个集合类型的实现类
		// Set set = new HashSet();// 创建set
		List list = new ArrayList();// 创建list
		Set<Student> set = new HashSet();// <Student>可以指定集合（容器）放Student对象
		// 2、调用方法
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s2);// set不能重复

		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s2);// list可以重复
//		reverseList(list); 
//调用 reverseList 方法之后，list倒序输出
		
		//查找元素的位置，有则返回位置（整形），没有返回-1
				int i = list.indexOf(s3);
				System.out.println("s3的位置为："+i);
		
		// 3、取集合里面的元素，需要使用工具迭代器：Iterator
		Iterator it1 = set.iterator();// set. 调用Iterator方法
		Iterator it2 = list.iterator();
		// 利用while遍历迭代器
		// it1.hasNext(),调用hasNext()方法：hasNext()：如果有值返回true，否则返回false
		/**
		 * java的迭代器的用法。
　		 * 	 　1)使用方法 iterator()要求容器返回一个 Iterator。第一次调用Iterator 的next()方法时，它返回序列的第一个元素。
　　		 *    2)使用next()获得序列中的下一个元素。
　		 *	 　3)使用hasNext()检查序列中是否还有元素。
　		 *	 　4)使用remove()将上一次返回的元素从迭代器中移除。
		 */
		System.out.println("输出it1（===set===）集合元素");
		while (it1.hasNext()) {
			// it1.next()取出元素，取出后强转为放入的元素类型，然后赋值给stu变量，这样就获得了集合里面的元素
			Student stu2 = (Student) it1.next();
			System.out.println(stu2);
		}

		System.out.println("输出it2（===list===）集合元素");
		
		/**直接println，能打印出集合里的全部元素，那什么时候需要遍历集合？
		 * 1.当你需要用到集合的某个元素，但又不知道该元素在集合的具体位置时，就需要遍历了
		 * 2.遍历集合，得到的是元素对象，print集合时系统会调用该集合的toString()方法，该方法返回的是集合元素组成的字符串 
		 */
		System.out.println("直接输出："+list);
		
		while (it2.hasNext()) {
			// it2.next()取出元素，取出后强转为放入的元素类型，然后赋值给stu变量，这样就获得了集合里面的元素
			Student stu3 = (Student) it2.next();
			System.out.println(stu3);
		}
	}
}

集合：Map_Test.java

package 集合;

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

public class Map_Test {
	public static void main(String[]srgs){
		Student s1 = new Student("zhangsan", 15);
		Student s2 = new Student("lisi", 16);
		Student s3 = new Student("wangwu", 17);
		
		// 1、new一个集合类型的实现类
		Map map = new HashMap();//new一个map类型的集合map，其中HashMap()为实现类
		
		// 2、调用方法
		map.put("1", s1);//需要输入两个对象类型参数 。    put(k-key,v-value)
		map.put("2", s2);//其中key方便取值，可为其他（a，sgah,sahs都可以）
		map.put("3", s3);
//		map.put("a", s3);//map中key可重复，但会覆盖前面的值
		// 3、取集合里面的元素，需要使用工具迭代器：Iterator
		Student stu =(Student)map.get("1");
		System.out.println(stu);
	}
}

集合的使用(存取和判断)：Student.java

package 集合;

/**
 * 1.集合：集合的框架（接口的继承关系以及实现类，见API）
 * 2.集合的使用：存、取、判断
 * 3.集合的区别：    List  有顺序，可重复
 * 				Set   无序，不可重复（重复并不报错，无法存入）
 * 				Map   键值对  key value 键的不可重复
 */
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

public class Student implements Comparable<Student>{//需要强转为Student类型
	private int age;
	private String name;

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

	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
	

	public String getName() {
		return name;
	}

	public static void main(String[] args) {
		// 关于集合Set的使用
		HashSet set = new HashSet();
		List list = new ArrayList();
		Student s1 = new Student("zhang3", 23);
		Student s2 = new Student("lisi", 22);
		Student s3 = new Student("wang5", 21);
		// ========存元素到集合里面=====
		set.add(s1);
		set.add(s2);
		set.add(s3);
		//set.add(s1);//放开后s1的值并不会重复显示，set值不重复
		list.add(s1);
		list.add(s2);
		list.add(s3);
		//list.add(s1);//放开后s1的值重复显示
		// ==========取集合里面的元素====
		Iterator it = set.iterator();
		Iterator it2 = list.iterator();
		while (it.hasNext()) {
			Student iw1 = (Student) it.next();//将it里面的值输出
			System.out.println(iw1);
		}
		System.out.println("========取 List  集合里面的元素");
		// ==========取List 集合里面的元素
		while (it2.hasNext()) {
			Student iw2 = (Student) it2.next();//it2中有重复的值会报错，iw
			if (iw2.name.equals("lisi")) {
				list.remove(iw2);//移除元素
				System.out.println(iw2);
			}
		}
		//集合排序:需要,实现CompareTo接口
		Collections.sort(list);
		System.out.println("paixu:"+list);
		int i=Collections.binarySearch(list, s1);
		System.out.println("s2所在的位置为："+i);
		
		//集合同数组一样，下标由0开始
		System.out.println("list 所有元素是：" + list);
		System.out.println("list 第二个元素是：" + list.get(1));
		
		//强转为Student类型后用getName()方法来获得名字
		System.out.println(((Student)list.get(1)).getName());
	}

	@Override
	public int compareTo(Student o) {//重载compareTo
		Student st=o;//自己写出比较方法
		return this.age-st.age;//按照年龄排序
	}
}

Map的遍历方法：Teacher.java

package 集合;

/**
 * 完成下列要求： 
 *	1）  使用一个 Map，以老师的名字作为键，以老师教授的课程名作为值，表示上述
 *		课程安排。
 *	2）  增加了一位新老师 Allen 教 JDBC 
 *	3）  Lucy 改为教 CoreJava 
 *	4）  遍历 Map，输出所有的老师及老师教授的课程
 *	5）  利用 Map，输出所有教 JSP 的老师。
 */
import java.util.*;
import java.util.Map.Entry;

public class Teacher {
	public static void main(String[] args) {
		// 定义map中键和值的类型
		Map<String, String> map = new HashMap<String, String>();
		map.put("Tom", "CoreJava");
		map.put("John", "Oracle");
		map.put("Susan", "Oracle");
		map.put("Jerry", "JDBC");
		map.put("Jim", "Unix");
		map.put("Kevin", "JSP");
		map.put("Lucy", "JSP");

		// 增加新老师
		map.put("Allen", "JDBC");

		// 更改
		map.put("Lucy", "CoreJava");

		// 输出map的值
		// System.out.println(map.toString());

		// // 遍历map
		// Collection c1 = map.values();// 值遍历
		// Iterator it1 = c1.iterator();
		// while (it1.hasNext()) {
		// System.out.println(it1.next());
		// }

		// Collection c2 = map.keySet();// 键遍历
		// Iterator it2 = c2.iterator();
		// while (it2.hasNext()) {
		// System.out.println(it2.next());
		// }

		// 键值遍历
		/*
		 * Set s1= map.keySet(); Iterator it3 =s1.iterator();
		 * while(it3.hasNext()){ Object key =it3.next(); System.out.println(key+
		 * " = "+map.get(key)); }
		 */

		// 键值遍历二
		// Set s2= map.keySet();
		// Iterator it4 =s2.iterator();
		// while(it4.hasNext()){
		// Object key =it4.next();
		// System.out.println(key+" = "+map.get(key));
		// }

		// 遍历Map，输出所有的老师及老师教授的课程
		//Entry 键值对
//		Set<Entry<String, String>> set = map.entrySet();
//		Iterator<Entry<String, String>> it = set.iterator();
//		while (it.hasNext()) {
//			Entry<String, String> e = it.next();
//			System.out.println(e.getKey() + "\t" + e.getValue());
//		}

		// 从map中得到Tom教授的课程并打印到控制台
//		String course = map.get("Tom");
//		System.out.println("Tom教的课程是: " + course);

		// Set<String> set = map.keySet();
		// 迭代一集合对象之所有成员
		// for (String str : set) {//foreach：增强型循环
		// if (map.get(str).equals("JSP")) {
		// System.out.println(str);
		// }
		// }
		// 方法二
		Set s2 = map.keySet();// 将map的key赋给s2
		// 利用迭代器遍历
		Iterator it4 = s2.iterator();
		while (it4.hasNext()) {
			Object key = it4.next();
			// map.get(value):表示map中的值
			if (map.get(key).equals("JSP"))
				System.out.println(key + " 教 " + map.get(key));
		}
	}
}