2017年4月5号 晴 轻度雾霾

内容：Set,Map,遍历集合的方法，泛型，小Demo，Collections工具类的使用

一、Set

老师代码：

package cn.bdqn.test;

import java.util.HashSet;
import java.util.Set;

import org.junit.Test;

public class SetTest {

public static void main(String[] args) {
Set set = new HashSet();
set.add("1");
set.add(new String("1"));
System.out.println(set.size());

/**
* 01.hashSet的底层是什么？
* public HashSet() {
map = new HashMap<>();
}
* 02.set.add做了什么？
* public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
我们新增的值，作为map中的key
03.map中的key为什么是唯一的？ 为什么size()是1？
底层代码得知！
001.先比较两个值的hashCode
002.比较内存地址和内容 ，两者有一个为true就认为是一个值！
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
* 04.set保存的是什么？
* 唯一，无序的数据！
*/
}

@Test
public void test01() {
Set set = new HashSet();
set.add("1");
set.add(new String("1"));
set.add(1);
System.out.println(set.size()); // 2
}

}

二、Map

老师代码：

package cn.bdqn.test;

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

public class MapTest {

public static void main(String[] args) {
Map countries = new HashMap(); // 创建一个map集合
/**
* 向集合中新增数据
* cn us：就是 key 也称之为 键
* 大中国： 就是value 也称之为 值
*/
countries.put("cn", "大中国");
countries.put("fr", "刷锅");
countries.put("us", "小美国");
System.out.println(countries.size()); // 3
// 删除us 根据key删除value 返回删除的value
System.out.println(countries.remove("us"));
// 获取指定key的value
String s = (String) countries.get("us"); // 向下转型
System.out.println(s);
// 查询集合中是否包含某个对象
System.out.println("是否包含us的key：" + countries.containsKey("us"));
System.out.println("是否包含‘大中国’的value：" + countries.containsValue("大中国"));
// 清空集合
countries.clear();
System.out.println("清空之后的大小：" + countries.size());

}

}

三、遍历集合的几种方法

老师代码：

1）user类

package cn.bdqn.foreach;

public class User { // 用户的实体类

private int id; // 用户的编号 是唯一的！
private String name; // 用户名
private String pwd; // 密码
private int age; // 年龄

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 getPwd() {
return pwd;
}

public void setPwd(String pwd) {
this.pwd = pwd;
}

public int getAge() {
return age;
}

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

public User(int id, String name, String pwd, int age) {
super();
this.name = name;
this.id = id;
this.pwd = pwd;
this.age = age;
}

public User() {
super();
}

@Override
public String toString() {
return "User [姓名=" + name + ", 密码=" + pwd + ", 年龄=" + age + "]";
}

}

2）Mapuser类

package cn.bdqn.foreach;

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

import org.junit.Test;

public class MapUser {

public static void main(String[] args) {
// 创建多个用户 shift +alt +a
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);

// 创建一个map集合
Map users = new HashMap();
// 把用户放入到map集合中
users.put(user1.getId(), user1);
users.put(user2.getId(), user2);
users.put(user3.getId(), user3);
// 遍历集合 前提:必须拿到key的集合 keySet：
Set keySet = users.keySet();
/**
* Object：指的是 集合中每一个元素的类型
* key: 变量名
* keySet：需要遍历的集合
*/
①for (Object key : keySet) {
// 通过key获取value值
User user = (User) users.get(key);
/**
* 默认输入对象的时候，会执行对应类中 toString()
* 如果类中没有重写object中的toString()
* 那么输出的结果是
* getClass().getName() + "@" + Integer.toHexString(hashCode());
*/
System.out.println(user);
}
}

//② Iterator 迭代器遍历：
@Test
public void test01() {
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);
Map users = new HashMap();
users.put(user1.getId(), user1);
users.put(user2.getId(), user2);
users.put(user3.getId(), user3);
System.out.println("***********************************");
// 遍历map 前提始终是获取key的集合
Set keySet = users.keySet();
/**
* Iterator接口中，只有三个方法
* 01.hasNext()判断是否有下一个元素！ 返回值是 boolean
* 02.next()获取下一个元素的值！ 返回值是泛型的类型
* 03.remove()删除元素 ！ 没有返回值
*/
Iterator it = keySet.iterator(); // 获取iterator对象
while (it.hasNext()) {
int key = (int) it.next(); // key都是int类型
User user = (User) users.get(key); // value都是User对象
System.out.println(user);
}
}

//③ 获取所有的value集合：
@Test
public void test02() {
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);
Map users = new HashMap();
users.put(user1.getId(), user1);
users.put(user2.getId(), user2);
users.put(user3.getId(), user3);
System.out.println("***********************************");
Collection values = users.values();
for (Object user : values) {
System.out.println(user);
}
}

/**
* ④Entry遍历! entrySet() 可以同时获取 key和value！
* 性能要比之前的Iterator 和 foreach高！
*/
@Test
public void test03() {
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);
Map users = new HashMap();
users.put(user1.getId(), user1);
users.put(user2.getId(), user2);
users.put(user3.getId(), user3);
System.out.println("***********************************");
Iterator it = users.entrySet().iterator();
while (it.hasNext()) {
Entry entry = (Entry) it.next(); // 返回结果是 Entry
System.out.println("map中的key:" + entry.getKey());
System.out.println("map中的value:" + entry.getValue());
}
}

/**
*
*⑤ 测试 Entry 和 Iterator 遍历的效率
*/
@Test
public void test04() {
User user = null;
Map users = new HashMap();
for (int i = 1; i <= 5000; i++) {
user = new User(i, "小黑1", "123", 500);
users.put(i, user);
}
System.out.println("***************foreach***************");
// 记录开始的时间
long begin = System.currentTimeMillis(); // 1970年1月1日到现在的毫秒数
Set keySet = users.keySet();
for (Object key : keySet) {
System.out.println(users.get(key));
}
long end = System.currentTimeMillis();
System.err.println("foreach用时：" + (end - begin));

System.out.println("**************Entry****************");
begin = System.currentTimeMillis();
Iterator it = users.entrySet().iterator();
while (it.hasNext()) {
Entry entry = (Entry) it.next();
System.out.println(entry.getValue());
}
end = System.currentTimeMillis();
System.out.println("Entry用时：" + (end - begin));
}

//⑥ getClass()
@Test
public void test09() {
User user = new User();
System.out.println(user.getClass()); // 对象名
System.out.println(User.class); // 类名
}

}

四、泛型

老师代码：

package cn.bdqn.foreach;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

public class ListTest {
public static void main(String[] args) {
List list = new ArrayList(); // 可以存放Object类型的数据
list.add(1);
list.add("1");
list.add(1.0);
list.add(true);

// 泛型集合
List<String> list2 = new ArrayList<String>();
// list2.add(1); 编译报错
}

@Test
public void test01() {
// 创建user对象
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);

List list = new ArrayList();
list.add(user1);
list.add("xxxx");
list.add(user3);
// 获取第二个用户
User user = (User) list.get(1);// 运行报错 ClassCastException
System.out.println(user);
}

@Test
public void test02() {
// 创建user对象
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);

List<User> list = new ArrayList(); // 集合中只能存储User类型的数据
list.add(user1);
// list.add("xxxx"); 编译报错！
list.add(user3);
// 获取第二个用户
User user = list.get(1);
System.out.println(user);
}

@Test
public void test03() {
// 创建user对象
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);
// 创建map集合
Map map1 = new HashMap(); // key 和value都是 Object
map1.put(1, "x");
map1.put("x", "x");
map1.put("x", true); // 用户可以随便增加数据的类型
}

@Test
public void test04() {
// 创建user对象
User user1 = new User(1, "小黑1", "123", 500);
User user2 = new User(2, "小黑2", "123", 500);
User user3 = new User(3, "小黑3", "123", 500);
// 创建map集合
Map<String, String> map1 = new HashMap(); // key 和value必须都是 String类型的数据
// 编译报错 map1.put(1, "x");
map1.put("x", "x");
// 编译报错 map1.put("x", true);
}

/**
* 以下代码！通用于set和map集合中
*/
@Test
public void test05() {
/**
* 编译报错！
* List<int> list = new ArrayList();
* 集合中的类型 必须是 引用数据类型！
* 不能传递基本数据类型，只能传对应的封装类！
*/
}

五、几个小Demo（类型转换）

老师代码：

/**
* 基本数据类型 double a=5; 自动类型转换 ====》数据类型大 =数据类型小
* Double b = 5.0 自动装箱 把基本数据类型，转换成对应的包装类！
*/
@Test
public void test06() {
double a = 5;
Double b = 5.0;
b = 5d;
b = 5D;
b = (double) 5;
}

@Test
public void test07() {
short a = 1;
// 编译报错 a=(a+1); 必须是 a=(short)(a+1)
a += 1; // 自动类型转换（自加自减默认强制类型转换）
}

六、Collections工具类的使用

 老师代码：

1）News类：

public class News implements Comparable {
private int id; //新闻编号
private String title; //新闻标题

@Override
public String toString() {
return "新闻 [编号=" + id + ", 标题=" + title + "]";
}

public News() { //无参构造
super();
}
public News(int id, String title) { //带参构造
super();
this.id = id;
this.title = title;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}

//重写 排序的规则 升序
@Override
public int compareTo(Object o) {
News news=(News) o;
if (news.getId()==this.id) {
return 0;
}else if (news.getId()<this.id) {
return 1; // 降序 return 1;
}else {
return -1; // 升序  return -1;
}
}
}

2）操作集合的工具类Collections：

public class CollectionsTest {

public static void main(String[] args) {
/*
* 操作集合的工具类Collections
*
*/
//创建一个集合
List<String> list=new ArrayList<String>();
list.add("b");
list.add("d");
list.add("c");
list.add("a");
System.out.println("没有排序====》"+list); //插入时候的顺序
//对集合进行随机排序
Collections.shuffle(list);
//开奖号码 136 顺序必须对 631不对
System.out.println("随机排序====》"+list);
//按照字母的升序排列
Collections.sort(list);
System.out.println("升序====》"+list);
//降序 也是必须在升序之后
Collections.reverse(list);
System.out.println("降序====》"+list);
//查询 "b"在集合中的位置 必须先升序 排列之后再查询
Collections.sort(list);
System.out.println(Collections.binarySearch(list, "a"));
System.out.println("****************************");
List<News> news=new ArrayList<News>(); //想实现对象的排序
news.add(new News(3, "新闻3"));
news.add(new News(1, "新闻1"));
news.add(new News(4, "新闻4"));
news.add(new News(2, "新闻2"));
for (News news2 : news) {
System.out.println(news2);
}
/*
* 如果News没有重写Comparable接口中的compareTo（）是编译报错的！
* 我们必须重写compareTo（） 定义规则
*/
Collections.sort(news);
System.out.println("对象排序之后.........");
for (News news2 : news) {
System.out.println(news2);
}
}

@Test
public void test1(){
//通过String类中的split（）把字符串转换成字符串数组
String[] str1="a b c d d d".split(" ");
//把数组转换成集合
List<String> asList = Arrays.asList(str1);
System.out.println(asList);
String[] str2="c d".split(" ");
List<String> asList2= Arrays.asList(str2);
//最后一次出现的位置
System.out.println(Collections.lastIndexOfSubList(asList, asList2));
//首次出现的位置
System.out.println(Collections.indexOfSubList(asList, asList2));
}

@Test
public void test2(){
String[] str1="a b c d e f".split(" ");
//把数组转换成集合
List<String> list = Arrays.asList(str1);
System.out.println(list);
//集合中的元素向后移distance个位置，之后被覆盖的元素循环前移
Collections.rotate(list, 2);
System.out.println(list);
}
}

3）Collections的几个方法操作实例：

4）汉字的排序（面试题）：

public class ListTest {

public static void main(String[] args) {
//实现都汉字的排序 传入一个语言环境
Comparator<Object> collator=Collator.getInstance(Locale.CHINA);
ArrayList<String> list=new ArrayList<String>();
list.add("你好");
list.add("好");
list.add("啊");
list.add("它好");
//工具类
Collections.sort(list, collator);
for (String string : list) {
System.out.println(string);
}
}

}

七、作业

1、整理集合框架(用MindManager),下图内容加上vector,map和泛型集合！下节课上课前交到ftp上！

2、视频：看到IO

3、做题（刘亚博每天都坚持做60题，向他学习！）

八、考试

（一）上午课堂测验：

88分 ，全班平均分83，勉强下午免考

考试后补充的两个知识点：

1、通配符泛型:

为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”。

使用通配泛型格式为<? extends Collection>，“？”代表未知类型，这个类型是实现Collection接口。

使用Java泛型时要注意：

1）如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。

2）通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。

3）泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。

2、swap(List<?>, int, int) 方法被用于交换在指定列表中的指定位置的元素。

 （二）下午考试

2017.04.05
15: 45开始，16:10结束；答题时间：25分钟；检查时间：0分钟；
成绩：65分
刘亚博同学表示下午考试很难，出于好奇参加下午考试。结果巨惨！第一次80分以下！

考后总结知识点：（待整理）

九、老师辛苦了！