黑马程序员技术交流社区

标题: 拒绝复制手打精品推荐, [打印本页]

---

作者: wjiuchaol1    时间: 2015-12-15 22:31
标题: 拒绝复制手打精品推荐,
双列集合:
map
k.映射维护键类型
v. 映射值的类型
一个映射不能包含重复的键
每个键最多值能映射到一个值

map是双列的. collection是单列的
map的键是唯一的. collection的子体细set是唯一的
map集合的数据结构值针对键有效,. 跟值无关 collection集合数据结构是针对元素有效

注意.
hashSet 底层依赖的是HasMap.
功能:
        添加:put(); 如果键是第一次添加 反悔null 如果不是第一次添加就用新值去替换就值
并且将就值返回

        删除:remove() 根据键删除该键值对 并且返回值 clear();

        判断:isEmpty()
             containskey()  containsValue

        获取: entryset  keyset get valuse

        长度:size() 返回键值对 的对数

Map<String , Integer> map = new HashMap<>();
Integer i1 = map.put("张散",23);
Integer i2 = map.put("张散",23);
Integer i3 = map.put("张散",23);
Integer i4 = map.put("张散",23); 相同的键不存储 覆盖的值返回

System.out.println(i1)
System.out.println(i2)
System.out.println(i3)
System.out.println(i4)



Map<String , Integer> map = new HashMap<>();
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)

//Integer value =map.remove("张三");
//System.out.println(value);
System,.out.println(map.containsKey("张三"));
System,.out.println(map.containsvalue("100"));
system.out.println(map);



Map<String , Integer> map = new HashMap<>();
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)
collection<Integer> c =  map.values();
System.out.println(c);
System.out.println(map.size());


双列集合如何遍历
1:根据键找值
获取键集合Ketset
遍历键的集合,.获取到每一个键 增强for 迭代骑也可以
根据键找到对应的值   get()

2.根据键值对对象 找键和值.
获取所有键值对的集合
遍历键值对的集合获取到每一个兼职对
根据键值对对象 找到对应的键和值

Map<String , Integer> map = new HashMap<>();
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)

Integer i = map.get("张三"); // 根据键获取值
System.out.println(i);

//获取所有的键
Set<String> keySet = map.KeySet(); //键集合
Iterator<String> it = KeySet.iterator();//获取大袋其
while(it.hasNext()) //判断集合中是否有元素
String Key = it.next(); //获取每一个贱
Integer value = map.get(key) //根据键获取值
System.out.println(key + ".."+value);

增强for循环:
for(String key : map.keyset()) //map.keyset获取所有键的集合
System.out.println(key + "= " map.get(key));


根据兼职对对象 获取键和值:
Map<String , Integer> map = new HashMap<>();
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)
map.put("张散",23)

set<map.Enery<String,integer>> entrySet = map.entrySet();
Iterator<map.Enery<String,integer>> it = entrySet.iterator();
while(it.hasNext())
map.Entry<String,Integer> en = it.next();
String key = en.getKey()
Integer value = en.Getvalue();
System.out.println(key+ "=" + value)






inteerface inter
interface inter2
public void show();

class Demo implements inter.inter2

public void show()



增强for:
for(Enery<String,integer >) en: map.entryset()
System.out.println(en.getKey() + "=" en.getvalue);

HashMap集合键是Student值是String
键是学生对象,代表每一个和学生\
值是字符串对象,代表学生归属第

HashMap<Student, String> hm = new HashMap<>();
hm.put(new Student("张散",23),"北京");
hm.put(new Student("张散的",23),"南京");
hm.put(new Student("张散的是",23),"东京");
hm.put(new Student("张散啊",23),"取经");

System.out.println(hm);

HashMap:
如果存储的元素 键是自定义类型 要保证键的唯一.必须重写Hashcode和equals方法
输出语句直接打印对象默认调用的是该对象的toString方法
如果打印的不是地址值肯定是该类或者该类的父类重写了object类中的头String方法

linkedHashMap的特点:
底层是链表实现的.可以保证怎么存就怎么取 (存取一致)
知识点回顾:
        linkedHashSet : 他是Set体系中唯一一个可以保证存取一直的集合类
       

LinkedHashMap<Student, integer> lhm  = new LinkedHashhMap<>();

lhm.put("张撒贝宁",23);
lhm.put("张撒贝宁",23);
lhm.put("张撒贝宁",23);
lhm.put("张撒贝宁",23);

System.out.println(lhm);

treeMap:
存储的键如果是自定义类型 如何保证键的唯一性
第一种:
让该自定义类型实现Comparable借口 然后重写借口中的compareto方法

第二种:
创建TreeMap集合对象的时候传入一个比较器的借口comparator的子类对象 重写借口
       
TreeMap<Student , String> tm = new TreeMap<>(new comparator<Student>);
public int compre(Student s1 Student s2)
int num = s1.getName() .compareTp(s2.getName)
ruturn num == 0? S1.getAge - s2.getAge : num
tm.put(new Student("张散",233)."东京")
tm.put(new Student("张散的",223)."大板")
tm.put(new Student("张散是",213)."妈妈桑")
tm.put(new Student("张散啊",23333)."shit")

System.out.println(tm);

统计字符串每个字符出现次数,String str= "aaaabbbcccc";

思路:
<Character , Integer>  
定义一个需要被统计的字符串
将字符串转换为字符数组
定义双链集合存储字符串中字符和出现的次数
遍历字符数组获取每一个字符,并将字符存储在双列集合中
纯矗过程中要做判断.如果集合中不包含这个键.就将该字符当作键值为1存储
打印双列集合获取字符出现的次数
String s = "aaaavvvvvvvsdsdxafasdf"
char[] arr = s.toCharArray();
HashMap<Character, Integer> hm = new HashMap<>();
for(Char c : arr )
/*if(!hm.containsKey(c))
hm.put(c,1);
else
hm.put(c,hm.get(c)+1)*/

hm.put(c.!hm.containsKey(c)? 1:hm.get(c)+1);
for(Character Key : hm.keySet())
System.out.println(Key + "=" + hm.get(Key));


集合嵌套HashMap嵌套HashhMap

需求.双园课堂很多基础班
第88期定义成一个双列集合.键是学生对象, 值是学生归属第
第99期定义成一个双列集合.键是学生对象, 值是学生归属第

无论88还是99 都是班级对象,为了便于统一管理把这些班级对象添加到双园课堂 集合中
HashMap<Student,String> hm88 = new HashWap
hm88.put(new Student("咋好难过",2122),"北京")
hm88.put(new Student("咋好的",222),"北京")
hm88.put(new Student("咋好难是过",232),"北京")
hm88.put(new Student("咋啊好难过",242),"北京")

HashMap<Student,String> hm99 = new HashWap
hm99.put(new Student("咋好是难过",2122),"北京")
hm99.put(new Student("咋好啊啊的",222),"北京")
hm99.put(new Student("咋好的难是过",232),"北京")
hm99.put(new Student("咋我我啊好难过",242),"北京")


HashMap<HashMap<Student,String>,String> hm = new HashWap

hm.put(hm,"88起基础班")
hm.put(hm,"99起基础班")

for(HashMap<Student,String> h : hm.KeySet())
String value = hm.get(h);
for(Student key:h.KeySet())
String value2 = h.get(Key);
System.out.println(Key + "="+ value2+ "="+value)


通过HashMap的嵌套来实现遍历的时候可以通过增强for的嵌套来做

重点面试题:HashMap和Hashtable的区别:
共同点: 底层都是哈希算法 都是双列集合
区别:
1,HashMap是线程不安全的.效率高,jdk.1.2版本
,Hashtable是现成安全的,. 效率底,jdk.1.0版本的
2,HasgMap可以存储null键和值
Hashtable不可以存储null键和null值


Collections : 操作Collection集合的工具类.
sort();
binarySearch();
max();
reverse();
shuffle();


ArrayList<String> list = new ArrayList<>();
list.add("c");
list.add("b");
list.add("a");
list.add("f");
list.add("d");

System.out.println(list);
Collections.sort(list);
System.out.println(list);



二分查找法:
ArrayList<String> list = new ArrayList<>();
list.add("c");
list.add("b");
list.add("a");
list.add("f");
list.add("d");
System.out.println(Collections.binrySearch(list,"c"));


获取最大值: Collection list
ArrayList<String> list = new ArrayList<>();
list.add("c");
list.add("b");
list.add("a");
list.add("f");
list.add("d");
System.out.println(Collections.max(list));


反转:
ArrayList<String> list = new ArrayList<>();
list.add("c");
list.add("b");
list.add("a");
list.add("f");
list.add("d");
Collections.reverse(list);
System.out.println(list);


随机排序:
ArrayList<String> list = new ArrayList<>();
list.add("c");
list.add("b");
list.add("a");
list.add("f");
list.add("d");

Collections.shuffle(list);
System.out.println(list);

以上全都是list体系.gogogo!


发扑克.这么长是要搞死我啊
分析:买一副扑克.其实就是自己创建一个集合对象,将扑克排存储进去
洗牌
发牌
看牌

String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q""K"};
String[] color = {"红桃"."黑桃","方片","梅花"};
ArrayList<String> poker new ArrayList<>();

for(String s1 : color)
for(String s2 : num)
poker.add(s1.concat(s2)); //连接两个字符串

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2