Java学习笔记（17）

双列集合：

------------------| Map　　如果是实现了Map接口的集合类，具备的特点是：存储的数据都是以键值对的形式存在的键不可重复，值可以重复

----------------------| HashMap

----------------------| TreeMap

----------------------| Hashtable

Map集合的方法：

添加：
　　put(K key, V value)
　　putAll(Map<? extends K,? extends V> m)

public class Demo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<String, String> map=new HashMap<String,String>();
        //添加方法
        map.put("汪峰", "章子怡");
        map.put("文章", "马伊琍");
        map.put("许一清", "沈某");
        System.out.println("返回值:"+map.put("许一清", "宋某"));//如果之前没有存在该键，那么返回的是null，如果之前就已经存在该键了，那么就返回之前该键对应的值
        map.put("狗娃", "宋某");
        System.out.println("集合的元素是:"+map);
        
        Map<String, String> map2=new HashMap<String,String>();
        map2.put("系综", "彭总");
        map2.put("狗蛋", "郝某");
        map.putAll(map2);//把map2的元素添加到map集合中
        
        System.out.println("集合的元素:"+map);
    }

}

结果：
返回值:沈某
集合的元素是:{狗娃=宋某, 文章=马伊琍, 汪峰=章子怡, 许一清=宋某}
集合的元素:{狗娃=宋某, 文章=马伊琍, 狗蛋=郝某, 汪峰=章子怡, 许一清=宋某, 系综=彭总}

删除:
　　　　remove(Object key) 　　　　 根据键删除一条map中的数据，返回的是其对应的值
　　　　clear() 　　　　 清空集合的元素数据

获取：
　　get(Object key)　　根据键获取对应的值
　　size()　　　　获取map集合中键值对的个数

判断：
　　containsKey(Object key)　　　　　　判断map集合是否包含指定的键
　　containsValue(Object value) 　　　　判断map集合是否包含指定的值

　　isEmpty()　　　　判断map是否为空

null可以作为键和值存入集合

迭代：
　　keySet()
　　values()
　　entrySet()

public class Demo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<String, String> map=new HashMap<String,String>();
        //添加方法
        map.put("汪峰", "章子怡");
        map.put("文章", "马伊琍");
        map.put("许一清", "沈某");
        //System.out.println("返回值:"+map.put("许一清", "宋某"));//如果之前没有存在该键，那么返回的是null，如果之前就已经存在该键了，那么就返回之前该键对应的值
        map.put("狗娃", "宋某");
        //添加方法
        /*Map<String, String> map2=new HashMap<String,String>();
        map2.put("系综", "彭总");
        map2.put("狗蛋", "郝某");
        map.putAll(map2);//把map2的元素添加到map集合中
*/        
        //System.out.println("集合的元素:"+map);
        System.out.println("根据指定的键获取对应的值:"+map.get("文章"));
        System.out.println("map集合中键值对的个数:"+map.size());
        System.out.println(map.isEmpty());
        System.out.println("集合的元素是:"+map);
        map.remove("狗娃");
        map.clear();
        
        System.out.println("集合的元素是:"+map);
    }

}

结果：
根据指定的键获取对应的值:马伊琍
map集合中键值对的个数:4
false
集合的元素是:{狗娃=宋某, 文章=马伊琍, 汪峰=章子怡, 许一清=沈某}
集合的元素是:{}

 Map的三种遍历方式：

package cn.itcast.map;

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;

/*
 
 迭代：
          keySet()    把map集合中的所有键都保存到一个Set类型的集合对象中返回        缺点：keySet方法只是返回了所有的键，没有值
          values()     把所有的值存储到一个Collection集合中返回        缺点：values方法只能返回所有的值，没有键
          entrySet()
          
  
  */
public class Demo3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<String, String> map=new HashMap<String,String>();
        //添加方法
        map.put("汪峰", "章子怡");
        map.put("文章", "马伊琍");
        map.put("许一清", "沈某");
        map.put("成龙", "林凤娇");
        //map集合中遍历方式一：使用keySet方法进行遍历
        Set<String> keys=map.keySet();
        Iterator<String> it=keys.iterator();
        while (it.hasNext()) {
            String key=it.next();
            System.out.println("键:"+key+" 值:"+map.get(key));
        }
        
        //map集合的遍历方式二：使用values方法进行遍历
        Collection<String> c=map.values();
        Iterator<String> it2=c.iterator();
        while (it2.hasNext()) {
            System.out.println("值:"+it2.next());
        }
        
        //map集合的遍历方式三： 使用entrySet方法进行遍历
        Set<Map.Entry<String,String>> entrys=map.entrySet();
        Iterator<Map.Entry<String,String>> it3=entrys.iterator();
        while (it3.hasNext()) {
            Map.Entry<String,String> entry=it3.next();
            System.out.println("键:"+entry.getKey()+" 值:"+entry.getValue());
        }
    }

}

结果：
键:文章 值:马伊琍
键:成龙 值:林凤娇
键:汪峰 值:章子怡
键:许一清 值:沈某
值:马伊琍
值:林凤娇
值:章子怡
值:沈某
键:文章 值:马伊琍
键:成龙 值:林凤娇
键:汪峰 值:章子怡
键:许一清 值:沈某

HashMap：底层也是基于哈希表实现的

HashMap的存储原理：

　　　　往HashMap添加元素的时候，首先会调用键的hashCode方法，得到元素的哈希码值，然后经过运算就可以算出该元素在哈希表中的存储位置

1. 情况一：如果算出的位置目前没有任何元素存储，那么该元素可以直接添加到哈希表中
2. 情况二：如果算出的位置目前已经存在其他的元素，那么还会调用该元素d的equals方法与这个位置上的元素进行比较，如果equals方法返回的是false，那么该元素允许被存储，如果equals方法返回的是true，那么该元素被视为c重复元素，不允许存储

package cn.itcast.map;

import java.util.HashMap;

public class Demo5 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashMap<Person, String> map=new HashMap<Person,String>();
        map.put(new Person(110, "狗娃"), "001");
        map.put(new Person(220, "狗剩"), "002");
        map.put(new Person(330, "铁蛋"), "003");
        map.put(new Person(110, "狗娃"), "007");//如果出现了相同的键，那么后添加的数据的值会取代之前的值。
        System.out.println("集合的元素:"+map);
    }

}
class Person {
    int id;
    String name;
    public Person(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "[编号："+this.id+" 姓名："+this.name+"]";
    }
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        Person p=(Person)obj;
        return this.id==p.id;
    }
}

结果：
集合的元素:{[编号：330 姓名：铁蛋]=003, [编号：220 姓名：狗剩]=002, [编号：110 姓名：狗娃]=007}

TreeMap：TreeMap也是基于红黑树（二叉树）数据结构实现的，特点：会对元素的键进行排序存储

 TreeMap要注意的事项：

1. 往TreeMap添加元素的时候，如果元素的键具备自然顺序，那么就会按照键的自然顺序特性进行排序存储
2. 往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性，那么键所属的类必须要实现Comparable接口，把键的比较规则定义在CompareTo方法上
3. 往TreeMap添加元素的时候，如果元素的键不具备自然顺序特性，而且键所属的类也没有实现Comparable接口，那么就必须在创建TreeMap对象的时候传入比较器

package cn.itcast.map;

import java.util.Comparator;
import java.util.TreeMap;

public class Demo6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*TreeMap<Character, Integer> tree=new TreeMap<Character,Integer>();
        tree.put('c', 10);
        tree.put('b', 2);
        tree.put('a', 5);
        tree.put('h', 12);
        System.out.println(tree);*/
        //创建一个自定义比较器
        MyComparator comparator=new MyComparator();
        
        
        TreeMap<Emp, String> tree=new TreeMap<Emp,String>(comparator);
        tree.put(new Emp("冰冰", 2000), "001");
        tree.put(new Emp("家宝", 1000), "002");
        tree.put(new Emp("大总", 3000), "003");
        tree.put(new Emp("克己", 5000), "005");
        tree.put(new Emp("克人", 5000), "008");//相同的不会取代，但是值会取代
        System.out.println(tree);
    }

}
class Emp {//implements Comparable<Emp>{
    String name;
    int salary;
    public Emp(String name, int salary) {
        super();
        this.name = name;
        this.salary = salary;
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "[姓名："+this.name+" 薪水："+this.salary+"]";
    }

    /*@Override
    public int compareTo(Emp o) {
        // TODO Auto-generated method stub
        return this.salary-o.salary;
    }*/
}
class MyComparator implements Comparator<Emp> {

    @Override
    public int compare(Emp o1, Emp o2) {
        // TODO Auto-generated method stub
        return o1.salary-o2.salary;
    }
    
}

结果：
{[姓名：家宝 薪水：1000]=002, [姓名：冰冰 薪水：2000]=001, [姓名：大总 薪水：3000]=003, [姓名：克己 薪水：5000]=008}

 需求：定义一个TreeMap，键存储的是书对象，值存储的是字符串。根据书的出版日期排序

package cn.itcast.map;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TreeMap;

/*
 
 需求：定义一个TreeMap，键存储的是书对象，值存储的是字符串。根据书的出版日期排序
  
  
  */
public class Demo7 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TreeMap<Book, String> map=new TreeMap<Book,String>();//值存储书名
        map.put(new Book("红楼梦","1990-12-03"),"001");
        map.put(new Book("西游记","1993-08-13"),"002");
        map.put(new Book("水浒传","1989-04-03"),"003");
        map.put(new Book("三国演义","1997-10-04"),"004");
        System.out.println(map);
    }

}
class Book implements Comparable<Book>{
    String name;
    String date;//出版日期
    public Book() {}
    public Book(String name, String date) {
        super();
        this.name = name;
        this.date = date;
    }
    //利用字符串的CompareTo方法进行排序
    /*@Override
    public int compareTo(Book o) {
        // TODO Auto-generated method stub
        return this.date.compareTo(o.date);
    }*/
    
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "[ 书名："+this.name+" 出版日期："+this.date+"]";
    }
    //先把字符串的日期转换Date对象，然后再使用Date对象进行比较
    @Override
    public int compareTo(Book o) {
        // TODO Auto-generated method stub
        //日期格式化类
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd");
        //使用日期格式化类把字符转换成Date对象
        Date date1=null;
        Date date2=null;
        try {
            date1=dateFormat.parse(this.date);
            date2=dateFormat.parse(o.date);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        return date1.compareTo(date2);
    }
    
}

结果：
{[ 书名：水浒传 出版日期：1989-04-03]=003, [ 书名：红楼梦 出版日期：1990-12-03]=001, [ 书名：西游记 出版日期：1993-08-13]=002, [ 书名：三国演义 出版日期：1997-10-04]=004}

HashTable:底层也是依赖了哈希表实现的，也就是实现方式与HashMap是一致的，但是HashTable是线程安全的，操作效率低。

Collections：

Collections：常见方法：
1， 对list进行二分查找：
　　　//前提该集合一定要有序。
　　　　int binarySearch(list,key);
　　　　int binarySearch(list,key,Comparator);
2，对list集合进行排序。
　　　　sort(list);
　　　　sort(list,comaprator);
3，对集合取最大值或者最小值。
　　　　max(Collection)
　　　　max(Collection,comparator)
　　　　min(Collection)
　　　　min(Collection,comparator)
4，对list集合进行反转。
　　　　reverse(list);
8，可以将不同步的集合变成同步的集合。
　　　　Set synchronizedSet(Set<T> s)
　　　　Map synchronizedMap(Map<K,V> m)
　　　　List synchronizedList(List<T> list)　　

package cn.itcast.util;

import java.util.ArrayList;
import java.util.Collections;

/*
 
 集合的工具类(Collections):
     说出Collection与Collections的区别
         1.Collection是一个单例集合的根接口，Collections是操作集合对象的一个工具类
Collections：常见方法：
1，    对list进行二分查找：
        前提该集合一定要有序。
        int binarySearch(list,key);
        int binarySearch(list,key,Comparator);
2，对list集合进行排序。
        sort(list); 
        sort(list,comaprator);
3，对集合取最大值或者最小值。
        max(Collection)
        max(Collection,comparator)
        min(Collection)
        min(Collection,comparator)
4，对list集合进行反转。
        reverse(list);
8，可以将不同步的集合变成同步的集合。
        Set synchronizedSet(Set<T> s)        Collections.synchronizedSet(Set<T> s)会返回一个线程安全的Set集合
        Map synchronizedMap(Map<K,V> m)
        List synchronizedList(List<T> list)
 
  
  */
public class Demo1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Integer> list=new ArrayList<Integer>();
        list.add(12);
        list.add(1);
        list.add(2);
        list.add(19);
        //排序
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        System.out.println("元素所在的索引值是:"+Collections.binarySearch(list, 12));
        System.out.println("最大值是:"+Collections.max(list));
        System.out.println("最小值是:"+Collections.min(list));
        Collections.reverse(list);
        System.out.println(list);
        //System.out.println(list);
    }


}

结果：
[12, 1, 2, 19]
[1, 2, 12, 19]
元素所在的索引值是:2
最大值是:19
最小值是:1
[19, 12, 2, 1]

package cn.itcast.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo2 {
    //如果单例集合存储的都是不具备自然顺序的元素，那么排序需要传入比较器
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Person> list=new ArrayList<Person>();
        list.add(new Person("狗娃", 12));
        list.add(new Person("张三", 22));
        list.add(new Person("铁蛋", 2));
        Collections.sort(list, new AgeComparator());
        System.out.println("集合中的元素:"+list);
        System.out.println("找到的索引值是:"+Collections.binarySearch(list,new Person("铁蛋", 2),new AgeComparator()));
        System.out.println("最大值是:"+Collections.max(list,new AgeComparator()));
        System.out.println("最小值是:"+Collections.min(list,new AgeComparator()));
    }

}
class Person {
    String name;
    int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "{姓名："+this.name+" 年龄："+this.age+"}";
    }
}
class AgeComparator implements Comparator<Person> {

    @Override
    public int compare(Person o1, Person o2) {
        // TODO Auto-generated method stub
        return o1.age-o2.age;
    }
    
}

结果：
集合中的元素:[{姓名：铁蛋 年龄：2}, {姓名：狗娃 年龄：12}, {姓名：张三 年龄：22}]
找到的索引值是:0
最大值是:{姓名：张三 年龄：22}
最小值是:{姓名：铁蛋 年龄：2}

 Arrays:

1，二分查找,数组需要有序
　　binarySearch(int[])
　　binarySearch(double[])

2，数组排序
　　sort(int[])
　　sort(char[])
2， 将数组变成字符串。
　　toString(int[])

没学过:
3， 复制数组。
　　copyOf(boolean[] original, int newLength);
　　　　original:源数组
　　　　newLength:新数组的长度
4， 复制部分数组。
　　copyOfRange(byte[] original, int from, int to)
　　　　original:源数组
　　　　from:开始拷贝的索引值
　　　　to:结束的索引值
5， 比较两个数组元素是否一致。
　　equals(int[],int[]);
6， 将数组变成集合。
　　List asList(T[]);

package cn.itcast.util;

import java.util.Arrays;
import java.util.List;

/*
 
 1，二分查找,数组需要有序
    binarySearch(int[])
    binarySearch(double[])

2，数组排序
    sort(int[])
    sort(char[])
2，    将数组变成字符串。
     toString(int[])
     
没学过:    
3，    复制数组。
     copyOf(boolean[] original, int newLength);
         original:源数组
         newLength:新数组的长度
4，    复制部分数组。
    copyOfRange(byte[] original, int from, int to)
        original:源数组
        from:开始拷贝的索引值
        to:结束的索引值
5，    比较两个数组元素是否一致。
    equals(int[],int[]);
6，    将数组变成集合。
    List asList(T[]);
  
  */
public class Demo3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer[] arr= {10,8,6,9};//如果是int类型的话，后面多余的元素会是0，但是如果是Integer的话，后面的元素就是null了
        Integer[] arr2=Arrays.copyOf(arr, 6);
        Integer[] arr3=Arrays.copyOfRange(arr, 1, 3);
        System.out.println("arr2拷贝后的数组元素是:"+Arrays.toString(arr2));
        System.out.println("arr3拷贝后的数组元素是:"+Arrays.toString(arr3));
        System.out.println("判断两个数组对应位置的元素是否完全一致:"+Arrays.equals(arr, arr2));
        
        List<Integer> list=Arrays.asList(arr);//把数组变集合
        list.toArray();   //把集合变数组
        System.out.println("集合的元素:"+list);
    }

}

结果：
arr2拷贝后的数组元素是:[10, 8, 6, 9, null, null]
arr3拷贝后的数组元素是:[8, 6]
判断两个数组对应位置的元素是否完全一致:false
集合的元素:[10, 8, 6, 9]

 eclipse：

alt+/ 内容补全键
Ctrl+1 快速修复键
alt+上下方向键 移动代码
tab 整体向右移动
shift+tab 整体向左移动
ctrl+/ 取消或者添加单行注释
ctrl+shift+f 代码格式化
ctrl+sgift+o 快速导包
ctrl+d 删除当前行代码
ctrl+shift+t 查看源代码 ctrl+鼠标点击或者F3

断点调试
step over 跳过本行代码
step into 进入方法内部
step return 结束方法，返回数据

正则表达式：正则表达式其实就是用于操作字符串的一个规则，正则表达式的规则使用了特殊的符号表示

需求：校验一个qq号

package cn.itcast.regex;
/*

  正则表达式:
  需求：校验一个qq号
      1.不能以0开头
      2.长度5~11
      3.只能由数字组成
  
  */
public class Demo1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String qq="45122257";
　　　　　//System.out.println(qq.matches("[1-9]\\d{4,10}")?"合法QQ":"非法QQ");
        if (!qq.startsWith("0")) {
            if (qq.length()>=5&&qq.length()<=11) {
                try {
                    Long.parseLong(qq);
                    System.out.println("恭喜你，你得到了一个合法QQ");
                }
                catch (Exception e) {
                    System.out.println("非法QQ，QQ号只能由数字组成");
                }
            }
            else {
                System.out.println("非法QQ，QQ号的长度只能是5~11位");
            }
        }
        else {
            //以0开头
            System.out.println("非法QQ，QQ号不能以0开头");
        }
    }

}

结果：
恭喜你，你得到了一个合法QQ

预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

注意：任何预定义字符没有加上数量词之前都只能匹配一个字符而已

数量词：

Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

范围词：

[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

注意：

范围词里面不管内容有多长，没有数量词的配合都只能匹配一个而已。

package cn.itcast.regex;

import java.util.Arrays;

/*
 
 匹配    matches()
 
 切割    split()
 
         看有多少组就看有多少对括号，依次从左往右的每一对括号就为第几组
         ((A)(B(C)))
         第一组：((A)(B(C)))
         第二组：(A)
         第三组：(B(C))
         第四组：(C)
     \1    引用第一组所匹配到的内容
     
 替换
 
 查找
 */
public class Demo3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //需求：编写一个正则表达式匹配一个手机号
        matchesPhone("13835026666");
        matchesTel("020-38325125");
        testSplit1();
        testSplit2();
    }
    public static void matchesPhone(String phone) {
        //String reg="1[34578]\\d{9}";
        System.out.println(phone.matches("1[34578]\\d{9}")?"合法手机号":"非法手机号");
    }
    //需求2:匹配固定电话
    public static void matchesTel(String tel) {
        System.out.println(tel.matches("0\\d{2,3}-[1-9]\\d{6,7}")?"合法固话":"非法固话");
    }
    //按照空格切割
    public static void testSplit1() {
        String str="明          天           放    假";
        String[] datas=str.split(" +");
        System.out.println("数组的元素:"+Arrays.toString(datas));
    }
    //根绝重叠词进行切割
    public static void testSplit2() {
        String str="大家家家明天天玩得得得得得得得得得得得开心";
        String[] datas=str.split("(.)\\1+");//如果正则的内容需要被复用，那么需要对正则的内容进行分组。分组的目的就是为了提高正则的复用性。组号不能指定，组号是从1开始
        System.out.println("数组的元素:"+Arrays.toString(datas));
    }
}

结果：
合法手机号
合法固话
数组的元素:[明, 天, 放, 假]
数组的元素:[大, 明, 玩, 开心]