Map:
Map:一次添加一对元素,Collection一次添加一个元素。
Map也称为上列集合,Collection集合称为单列集合
Map集合中,元素以键值对的形式存放。
Map集合中必须保证建的唯一性。
常见方法:
1、添加
value put(key ,value) :返回前一个和key相关联的值,如果没有返回null ;
2、删除
value clear() : 清空Map集合
value remove(Object key) :删除指定key对应的键值对。
3、判断
Boolean containsKey(key) ;
Boolean containsValue(Value) ;
Boolean isEmpty() ;
4、获取
value get(key) :通过键获得对应的值,如果没有则返回null。可以通过判读是不是null来判读是不是包含指定的键。
Int size() :获得键值对的个数。
public class MapTest {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>() ;
//第一次put是,返回的null
System.out.println(map.put("zhangsan","beijing")) ;
//再次添加相同的key是,返回的是key对应的旧值。
System.out.println(map.put("zhangsan", "tianjing"));
map.put("lishi", "wuhan") ;
map.put("wangwu", "shanghai") ;
System.out.println(map);
//移除一个键值队时,返回这个key对应的值
System.out.println(map.remove("wangwu"));
System.out.println(map);
System.out.println("has zhangsan :"+map.containsKey("zhangsan"));
System.out.println("has Beijing :"+map.containsValue("beijing"));
System.out.println("is Empty :"+map.isEmpty());
System.out.println("lishi :"+map.get("lishi"));
//当对应的key没有对应的值时,返回null。
System.out.println("wangwu :" +map.get("wangwu"));
}
}
结果:
遍历Map安排集合的两种方式:
1、通过keySet()方法拿到key的set集合,遍历key的集合,每次拿到key就取出对应的值。
2、通过entrySet 拿到所有的对应关系,遍历对应关系集合,直接通过对应的关系拿到键和值。
Map中没有迭代器,不能用器遍历集合。
public class MapErgodic {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>() ;
map.put("zhangsan", "wuhan") ;
map.put("zhaoliu", "shanghai") ;
map.put("lishi", "wuhan") ;
map.put("wangwu", "shanghai") ;
System.out.println(map);
ergodicByKey(map);
System.out.println("--------------");
ergodicByEntry(map);
}
//同过key遍历Map
public static void ergodicByKey(Map<String ,String> map){
//拿到map中所有的键的set集合
Set<String> set = map.keySet();
//遍历keyset,取出每个键
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
String key = iterator.next();
//通过键,取出对应的值
System.out.println(key+"=="+map.get(key));
}
}
//通过Map.entry,来遍历Map中的元素
public static void ergodicByEntry(Map<String, String> map){
//拿到list中所有的Map.entry
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//遍历entrySet集合
Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Map.Entry<String, String> entry = iterator.next();
//从Map.entry中 跟别取得键和值。
System.out.println(entry.getKey()+"=="+entry.getValue());
}
}
}
结果:
HashMap:
HashMap以Hashcode值和对象的equals方法判断键的唯一性。
Student 类:
class Student implements Comparable{
int age ;
String name ;
public Student(String name ,int age){
this.age = age ;
this.name = name ;
}
public String getname(){
return name;
}
public int getage(){
return age;
}
//Student本身的比较方法
//先按姓名排序,姓名相同,按年龄排序
@Override
public int compareTo(Object o) {
System.out.println(this.name+"..compareTo.."+((Student) o).getname());
int temp = this.name.compareToIgnoreCase(((Student) o).getname());
return temp== 0?this.age-((Student) o).getage():temp;
}
@Override
public int hashCode() {
System.out.println(this.name+" hash code..");
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println(this.name+"..equals.."+((Student) obj).getname());
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "[name=" + name + ",age=" + age + "]";
}
}
public class HashMapTest {
public static void main(String[] args) {
HashMap<Student,String> map = new HashMap<Student,String>() ;
Student t =new Student("wangwu",30) ;
map.put(new Student("zhangsan",10), "wuhan");
map.put(new Student("lisi",20), "beijing");
map.put(t, "shanghai");
map.put(new Student("zhangsan",10), "guangzhou");
System.out.println("-------------------");
//HashMap中,判读key是否重复,
//先判断hashCode值是否相等
//如果hashCode相等,则判断equals是否相等
t.age=12;
Set<Student>set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
Student key = (Student) iterator.next() ;
//每次取出元素时,
//先计算出参数key的Hashcode值,如果有相同的key,则认为有对应的值,就取出值。
//如果后来对键的的属性进行的操作后,后面可能会找不到key,造成内存泄漏。
//因为,hashcod和原来的值不同,而判读key是根据hashcode值判断的;
System.out.println(key+"=="+map.get(key));
}
}
}
结果:
TreeMap:
以compareTo方法判断键的唯一性。
public class TreeMapTest {
public static void main(String[] args) {
TreeMap<Student,String> map = new TreeMap<Student,String>() ;
Student t =new Student("wangwu",30) ;
map.put(new Student("zhangsan",10), "wuhan");
map.put(new Student("lisi",20), "beijing");
map.put(t, "shanghai");
map.put(new Student("zhangsan",10), "guangzhou");
System.out.println("-------------------");
//TreeMap 中判断key是否唯一,直接判断key对象的compareTo方法。不等于0则唯一
t.age=12;
Set<Student>set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
Student key = (Student) iterator.next() ;
//每次取出元素时,
//拿参数key和集合中的key做conpareTo比较,等于0时,则该key有对应值,返回其对应值,否则返回null
//如果后来对键的的属性进行的操作后,依然可以取出。
System.out.println(key+"=="+map.get(key));
}
}
}
结果:
“asdfasdf”获取字符串中,每个字母出现的次数。
要求:打印结果是a(1)b(2)...;
public class MapAbc {
public static void main(String[] args) {
//将字符串转换为 字符数组
char[] strs = StingToArry("asdlkfjassdfasdaasdf");
//定义TreeMap集合,可以按字母的自然顺序排序
TreeMap<Character,Integer> map = new TreeMap<Character,Integer>();
//定义字母出现的次数
int count = 0 ;
for(int i=0;i<strs.length;i++){
//先判断 字母对应的 次数
//由于的当集合没有该字母时,返回的是null,在判断之前将其归零。
if(map.get(strs[i])!=null)
count = map.get(strs[i]);
//次数加上一后,将字母对应的 次数存进去。
count++;
map.put(strs[i], count);
count =0 ;
}
arrayToString(map);
}
//将字符数组,按照格式打印出来
private static void arrayToString(TreeMap<Character, Integer> map) {
Set<Character> set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
char key = (char) iterator.next();
System.out.print(key+"("+map.get(key)+")");
}
}
private static char[] StingToArry(String string) {
return string.toCharArray();
}
}
结果:
Collections工具类:
Collectons:是集合框架的工具类,里面的方法都是静态的。
public class CollectionsTest {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("adlkj");
list.add("blkj");
list.add("cj");
list.add("e");
list.add("bfdkdlkj");
//collections,sort()方法 中自带的排序方式是按照对象的自然顺序
Collections.sort(list);
ergodic(list);
System.out.println("--------");
//sort()可以自定义比较方式,只要传递进去一个比较器就行
Collections.sort(list, new MyComparator2());
ergodic(list);
System.out.println("--------");
//打乱集合中元素的排列顺序
Collections.shuffle(list);
ergodic(list);
System.out.println("--------");
mySort(list,new MyComparator2());
ergodic(list);
}
//自定义的排序方法
//通过比较排序,实现按字字符串长度排序。
public static <T> void mySort(List<T> list,Comparator<? super T> com){
for(int i=0;i<list.size()-1;i++){
for(int j=i+1;j<list.size();j++){
if(com.compare(list.get(i),list.get(j))>0){
//交换集合中的两个元素
Collections.swap(list, i, j);
}
}
}
}
//遍历集合的方法
public static void ergodic(List<?> list){
Iterator<?> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
/*
* 自定义的比较器,重写conpare()方法
* 实现对字符串的长度比较
*/
class MyComparator2 implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
int temp = o1.length()-o2.length();
return temp==0? o1.compareTo(o2):temp;
}
}
结果:
Arrays:
Arrays是集合框架中的工具类,里面的方法都是静态的。
重点方法是 List asList() :将数组转换成List,转换过来的List集合的长度是固定的,自能进行改查的操作,增删会报错。
如果数组里面是对象,转换后来直接将对象拿过来,如果是基本类,则转换成相对应的包装类进行存储。
好处 :可以使用集合中的方法对数组进行操作。
public class ArraysTest {
public static void main(String[] args) {
String[] strs = new String[]{"abc","abd","abf","abf","abs"};
//数组本身的toString方法,是打印本身的hashcode值
System.out.println(strs);
//Arrays的toString方法可以将将数组按照一定的格式转换成字符串
System.out.println(Arrays.toString(strs));
//将数组转换成list
List<String> list = Arrays.asList(strs);
System.out.println(list.contains("abc"));
int[] arryint = new int[]{12,34,45};
//基本数据类型,只能将数组本身看成一个对象,m
//list中只有一个元素,就是数组本身
List<int []> list2 = Arrays.asList(arryint);
System.out.println(list2);
//使用基本类型的包装类,自动将基本数据类型包装成其包装类。
Integer[] arryint2 = new Integer[]{23,34,45};
List<Integer> list3 = Arrays.asList(arryint2);
System.out.println(list3);
}
}
结果:
集合转数组
使用Collection接口中的toArray方法。
将集合转换成数组后,可以对集合中的元素操作方法进行限制,不允许进行增删。
toArray方法需要传递进去一个指定类型的数组。
如果长度小于集合的size,该方法将会创建一个同类型并和集合size一样的数组。
如果长度大于集合的size,该方法将会使用传递进来的数组,其他位置为null。
最好,将传递进来的数组的长度设置成集合的size。
public class ListToArray {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("asd1") ;
list.add("asd2") ;
list.add("asd3") ;
list.add("asd4") ;
//当传递进来的数组长度小于list的size是
//会新建一个size和list大小一样的数组
String[] strs1 = (String[]) list.toArray(new String[1]);
System.out.println(Arrays.toString(strs1));
//当传递进来的数组长度过长时
//直接使用,传递进来的数组,没装满的位置是null
String[] strs = list.toArray(new String[10]);
System.out.println(Arrays.toString(strs));
//当传递进来的数组长度与list的size一样时
//不用新建数组,直接用传递进来的数组,不存在装不下,和空位置。
String[] strs2 = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(strs2));
}
}
结果: