黑马程序员——Java基础——集合（四）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

package cu.fu._10map;
/**
* Map常用的子类:
* 	HashMap:内部结构是哈希表,不同步.允许null作为键,null作为值.
* 	TreeMap:内部结构是二叉树,不同步,可以对Map集合中的键经行排序.
* 	Hashtable:内部结构是哈希表,是同步的.不允许null做为键,null做为值.
* 		Properties:用来存储键值对的配置文件的信息,可以和IO技术相结合.
*
* HashSet实现Set接口,由哈希表(实际上是一个HashMap实例)支持.
*/
import java.util.*;
class Student{
private String name;
private int age;

public Student(){}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
//去重的话需要重写方法HashCode和equals方法,可以不写
public int HashCode(){
final int PRIME = 31;
int result = 1;
result = PRIME*result+age;
result = PRIME*result+(name==null ? 0:name.hashCode());
return result;
}
public boolean equals(Object obj){
if(this ==obj){
return true;
}else if(obj==null){
return false;
}else if(!(obj instanceof Student)){//(this.getClass!=obj.getClass)
return false;
}else{
Student s = (Student)obj;
if(name == null){//本类对象姓名为空
if(s.name!=null){//但是对比对象姓名不为空
return false;
}
}else if(!name.equals(s.name)){//两个对象的name内容相同时
return false;
}
return true;

}
}
}

public class HashMapDemo {

public static void main(String[] args) {
HashMap<Student, String> hm = new HashMap<Student,String>();
hm.put(new Student("文天祥",22), "吉安");
hm.put(new Student("毛爷爷",35), "绍兴");
hm.put(new Student("兔子",24), "南昌");
hm.put(new Student("六六",22), "吉安");
Set<Map.Entry<Student, String>> se = hm.entrySet();
Iterator<Map.Entry<Student, String>> it = se.iterator();
while(it.hasNext()){
Map.Entry<Student, String> me= it.next();
Student s = me.getKey();
String st = me.getValue();
System.out.println(s.getName()+" "+s.getAge()+" "+st);

}
}

}

运行结果：
兔子 24 南昌

六六 22 吉安

毛爷爷 35 绍兴

文天祥 22 吉安

package cu.fu._10map;
/**
* Map在有映射关系时,可以优先考虑,在查表法中的应用较为多见
*/
import java.util.*;
public class HashMapDemo2 {
public static void main(String[] args) {
String week = getWeek(2);
System.out.print(week+" ");
System.out.println(getWeekByMap(week));

}
public static String getWeekByMap(String week){
Map<String,String> map = new HashMap<String,String>();
map.put("星期一", "Mon.");
map.put("星期二", "Tues.");
map.put("星期三", "Wen.");
map.put("星期四", "Thur.");
map.put("星期五", "Fri.");
map.put("星期六", "Sat.");
map.put("星期日", "Sun.");
return map.get(week);
}

public static String getWeek(int week){
if(week<1||week>7){
throw new RuntimeException("没有对应星期,请输入1~7之间的整数");
}
String[] weeks ={"","星期一","星期二","星期三","星期四","星期五","星期六","星期日",};
return weeks[week];
}
}

运行结果：
星期二 Tues.

package cu.fu._10map;
/**
* 使用LinkedHashMap是有序的,取出和输入顺序是一致的
*/
import java.util.*;
public class LinkedHashMapDemo {
public static void main(String[] args) {
LinkedHashMap<Integer,String> lh = new LinkedHashMap<Integer,String>();
lh.put(123, "哆唻咪");
lh.put(345, "咪发嗖");
lh.put(567, "嗖啦唏");
Set<Map.Entry<Integer, String>> se = lh.entrySet();
Iterator<Map.Entry<Integer,String>> it = se.iterator();
while(it.hasNext()){
Map.Entry<Integer, String> me = it.next();
System.out.println(me.getKey()+" "+me.getValue());
}

}

}

运行结果：
123 哆唻咪

345 咪发嗖

567 嗖啦唏

package cu.fu._10map;
/**
* Map HashMap TreeMap
* Map:一次添加一对元素,Collection一次添加一个元素.
* Map也称为双列集合,Collectiong集合称为单列集合.
* 其实Map集合中存储的就是键值对.
* Map集合中必须保证键的唯一性.
*
* 常用方法:
* 1.添加
* value put(key,value):返回之前Key关联的值,如果没有,返回null.
*
* 2.删除
* void clear():清空map集合.
* value remove(Object key):根据指定的key删除这个键值对.
*
* 3.判断
* boolean contiansKey(key);
* boolean isEmpty();
*
* 4.获取
* value get(key);	通过键获取值,如果没有该键返回null.
* 					也可以通过是否返回null,来判断是否包含指定键.
* int size();获取键值对的个数.
*/
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
Map<Integer,String>map = new HashMap<Integer,String>();
method(map);
}
public static void method(Map<Integer,String> map){
//添加元素
System.out.println(map.put(16, "小李子"));//null
System.out.println(map.put(14, "小顺子"));//null
System.out.println(map.put(14, "小德子"));//小顺子
System.out.println(map.put(17, "小孩子"));//null
System.out.println(map);//{17=小孩子, 16=小李子, 19=小德子, 14=小顺子}
map.put(3, "小白");
map.put(1, "小强");
System.out.println(map);//{17=小孩子, 1=小强, 16=小李子, 19=小德子, 3=小白, 14=小顺子}
//删除
System.out.println(map.remove(11));//null
System.out.println(map.remove(17));//小孩子
//判断
System.out.println(map.containsKey(14));//true
System.out.println(map.containsValue("小白"));//true
//获取
System.out.println(map.get(1));//小强
}
}

运行结果：
null

null

小顺子

null

{17=小孩子, 16=小李子, 14=小德子}

{17=小孩子, 1=小强, 16=小李子, 3=小白, 14=小德子}

null

小孩子

true

true

小强

package cu.fu._10map;
/**
* 获取Map集合元素并打印方式一:
*/
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo2 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer,String>();
method(map);
}

public static void method(Map<Integer,String> map){
map.put(8, "麦兜");
map.put(2, "麦麦");
map.put(4, "兜兜");
map.put(30,"麦太");
//取出map中的所有元素.
//原理,通过keySet方法获取map中所有的键在set集合,再通过set迭代器获取到每一键.
//再对一个键通过Map集合的get方法获取到对应的值即可.
Set<Integer> keyset = map.keySet();
Iterator<Integer> it = keyset.iterator();
while(it.hasNext()){
Integer key = it.next();
System.out.println(key+" "+map.get(key));
}

4000
}

}

运行结果：
2 麦麦

4 兜兜

8 麦兜

30 麦太

package cu.fu._10map;
/**
* 获取Map集合元素并打印,方式二
*/
import java.util.*;
public class MapDemo3 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
method(map);
}
public static void method(Map<Integer,String> map){
map.put(2, "牛逼");
map.put(3, "厉害");
map.put(9, "碉堡");
map.put(7, "伙呆");
//通过Map转成Set就可以迭代.(使用entrySet()方法返回一个包含键和值关系的Set视图,然后再用get方法取出)
//找到了另一个方法,entrySet.
//该方法将键和值的映射关系作为对象存储到了Set集合中,而这个映射关系的类型就是Map.Entry类型
Set<Map.Entry<Integer, String>> me = map.entrySet();
Iterator<Map.Entry<Integer, String>> it = me.iterator();
while(it.hasNext()){
Map.Entry<Integer, String> mm = it.next();
System.out.println(mm.getKey()+" "+mm.getValue());
}
System.out.println("---------------------");
//打印方式3(不完整,仅仅是返回map的值的Collection视图)
Collection<String> values = map.values();
Iterator<String> it2 = values.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}

}
}

运行结果：
2 牛逼

3 厉害

7 伙呆

9 碉堡

---------------------

牛逼

厉害

伙呆

碉堡

package cu.fu._10map;
/**
* 练习 “fdqavcbsacdfs”获取该字符串中，每一个字母出现的次数。
* 要求打印结果是：a(2)b(1)...;
*
* 思路:对于结果的分析发现,字母和次数之间存在着映射的关系,而且这种关系很多.
* 很多就需要存储,能存储映射关系的容器有数组和Map集合.
* 关系中并没有编号,那就使用Map集合.
* 发现可以保证唯一性的一方具备着顺序,如a,b,c...
* 所以可以使用TreeMap集合.
* 这个集合最终应该存储的是字母和次数的对应关系.
* 1.因为操作的是字符串中的字母,所以先将字符串变成字符数组.
* 2.遍历字符数组,用每一个字母作为键去查Map集合这个值.
* 如果该字母键不存在,就将该字母作为键,1作为值存储到集合中.
* 如果该字母存在,就将该字母键对应值取出并+1,再次存储到map集合中覆盖.
* 3.遍历结果,map集合就记录所有字母的出现次数.
*/
import java.util.*;
public class MapTest {
public static void main(String[] args) {
String s ="fdqavcbsacdfs";
System.out.println(s);
char[] arrays = s.toCharArray();
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
for(int i = 0 ;i<arrays.length;i++){
if(tm.get(arrays[i])==null){
tm.put(arrays[i], 1);
}else if(tm.get(arrays[i])!=0){
tm.put(arrays[i], tm.get(arrays[i])+1);
}
}
Set<Map.Entry<Character, Integer>> se = tm.entrySet();
Iterator<Map.Entry<Character, Integer>> it = se.iterator();
while(it.hasNext()){
Map.Entry<Character, Integer> me = it.next();
System.out.print(me.getKey()+"("+me.getValue()+")");
}
}
}

运行结果：
fdqavcbsacdfs

a(2)b(1)c(2)d(2)f(2)q(1)s(2)v(1)

package cu.fu._10map;
/**
* 根据年龄排序,创建比较器,排序要用Tree
*/
import java.util.*;
class ComparatorByAge implements Comparator<Student>{
public int compare(Student s1,Student s2){
int temp = s1.getAge()-s2.getAge();
return temp == 0 ? s1.getName().compareTo(s2.getName()):temp;
}
}

public class TreeMapDemo {

public static void main(String[] args) {
TreeMap<Student,String> tm = new TreeMap<Student,String>(new ComparatorByAge());
tm.put(new Student("喜羊羊",5), "cctv1");
tm.put(new Student("美羊羊",4), "cctv少儿");
tm.put(new Student("懒羊羊",2), "cctv3");
tm.put(new Student("灰太狼",7), "城堡别墅");
Set<Map.Entry<Student, String>> se = tm.entrySet();
Iterator<Map.Entry<Student, String>> it = se.iterator();
while(it.hasNext()){
Map.Entry<Student, String> me = it.next();
Student s = me.getKey();
System.out.println(s.getName()+" "+s.getAge()+" "+me.getValue());
}
}
}

运行结果：
懒羊羊 2 cctv3

美羊羊 4 cctv少儿

喜羊羊 5 cctv1

灰太狼 7 城堡别墅

package cu.fu._11Collections;
/**
* Collections:是集合的工具类,里面的方法都是静态的.
*/
import java.util.*;

class ComparatorByLength implements Comparator<String>{
public int compare(String s1,String s2){
int temp = s1.length()-s2.length();
return temp == 0?s1.compareTo(s2) : temp;
}
}

public class CollectionsDemo {
public static void main(String[] args) {
demo1();
System.out.println("------------------");
demo2();
System.out.println("------------------");
demo3();
System.out.println("------------------");
demo4();
System.out.println("------------------");
demo5();
}
public static void demo1(){
List<String> list = new ArrayList<String>();
list.add("cbc");
list.add("bcd");
list.add("xcz");
list.add("saad");
list.add("wqqsa");
//使用Collections工具类对list进行指定规则的排序.
//自然排序
Collections.sort(list);
System.out.println(list);//[bcd, cbc, saad, wqqsa, xcz]
//按照字符串长度排序
Collections.sort(list,new ComparatorByLength());
System.out.println(list);//[bcd, cbc, xcz, saad, wqqsa]
//按照指定的方法排序--选择排序
mySort(list,new ComparatorByLength());
System.out.println(list);//[bcd, cbc, xcz, saad, wqqsa]

}
public static void mySort(List list,ComparatorByLength comp){
for (int i = 0; i < list.size()-1; i++) {
for (int j = i+1; j <list.size(); j++) {
if(comp.compare((String)list.get(i), (String)list.get(j))>0){
Collections.swap(list, i, j);
}
}
}
}
public static void demo2(){
List<String> list = new ArrayList<String>();
list.add("cbc");
list.add("bcd");
list.add("xcz");
list.add("saad");
list.add("wqqsa");
Collections.sort(list);
System.out.println(list);//[bcd, cbc, saad, wqqsa, xcz]
//二分法查找数列list中的元素
System.out.println(Collections.binarySearch(list,"cbc"));//1
//寻找最大值,自然排序的最大值
System.out.println(Collections.max(list));//xcz
//寻找指定规则,长度最长的值
System.out.println(Collections.max(list,new ComparatorByLength()));
}
public static void demo3(){
//按照指定顺序存储元素到TreeSet中
//逆转长度顺序添加元素,即长的在前面
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
ts.add("jskdjls");
ts.add("asd");
ts.add("sadas");
ts.add("sdfsdg");
ts.add("tt");
ts.add("nbtyrtf");
System.out.println(ts);//[nbtyrtf, jskdjls, sdfsdg, sadas, asd, tt]
}
public static void demo4(){
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("tt");
list.add("jj");
list.add("abc");
System.out.println(list);//[abc, tt, jj, abc]
//替换所有列表中的指定元素
Collections.replaceAll(list,"abc","cdsn");
System.out.println(list);//[cdsn, tt, jj, cdsn]
}
public static void demo5(){
List<String> list = new ArrayList<String>();
list.add("nba");
list.add("kfc");
list.add("caonima");
list.add("nb");
System.out.println(list);
//随机排列元素顺序(洗牌)
Collections.shuffle(list);
System.out.println(list);
}
}

运行结果：
[bcd, cbc, saad, wqqsa, xcz]

[bcd, cbc, xcz, saad, wqqsa]

[bcd, cbc, xcz, saad, wqqsa]

------------------

[bcd, cbc, saad, wqqsa, xcz]

1

xcz

wqqsa

------------------

[nbtyrtf, jskdjls, sdfsdg, sadas, asd, tt]

------------------

[abc, tt, jj, abc]

[cdsn, tt, jj, cdsn]

------------------

[nba, kfc, caonima, nb]

[nba, nb, caonima, kfc]

package cu.fu._11Collections;
/**
* 给非同步集合加锁.
* 即将非同步集合变为同步集合.
*/
import java.util.*;

class MyCollections{
public List synList(List list){
return new MyList(list);
}
private class MyList extends ArrayList{
private List list;
private final Object lock = new Object();
MyList(List list){
this.list = list;
}
public boolean add(Object obj){
synchronized(lock){
return list.add(obj);
}
}
public boolean remove(Object obj){
synchronized(lock){
return list.remove(obj);
}
}
}
}

public class CollectionsTest {
public static void main(String[] args) {
List list = new ArrayList();//非同步的
list = new MyCollections().synList(list);//同步的
}
}

package cu.fu._12arrays;

import java.util.*;

/**
* Arrays:集合框架的工具类,里面的方法都是静态的.
* 重点:List asList(数组)将数组转换成集合
* 好处:可以使用集合的方法操作数组.
*/

public class ArraysDemo {
public static void main(String[] args) {
int[] arr ={1,4,3,6,3,2};
//将数组转换为指定数组内容的字符串形式
System.out.println(Arrays.toString(arr));
String[] s ={"kfc","vc","cctv","usa"};
//将字符串数组存入集合
List<String> list = Arrays.asList(s);
System.out.println(list.contains("usa"));
int[] arr2 = {918,315,11,502};
//注意:集合无法存储基本类型数据,只能存储对象,arr2作为一个对象存储到了集合中
List<int[]> list2 = Arrays.asList(arr2);
System.out.println(list2);
Integer[] arr3 = {918,315,11,502};
List<Integer> list3 = Arrays.asList(arr3);
System.out.println(list3);
}
}
/*
* P.S.
* 数组的长度是固定的,转换后的增删方法不可以用否是报异常
* UnsupportedOperationException.
* 数组转集合,用asList方法.
* 如果数组中的元素是对象,那么转成集合时,直接将数组中的元素作为集合中的元素进行集合存储.
* 如果数组中的元素是基本类型数值,那么会将该数组作为集合中的元素进行存储.
*/

运行结果：
[1, 4, 3, 6, 3, 2]

true

[[I@6f324b17]

[918, 315, 11, 502]