集合

//java基础视频教程第16天-01-集合（Map概述）
/*
    Map
        |--Hashtable
        |--HashMap
        |--TreeMap

    Map:方法
        增添
            put(K key,V value)
            putAll(Map<? extends K,? extends V> m)
        删除
        clear()
        remove()
        判断
        isEmpty()
        containsValue(Object value)
        containsKey(Object key)
        获取
        get(Object key)
        size()
        values()

        entrySet()
        keyeSet()
*/

//java基础视频教程第16天-02-集合（Map子类对象特点）
/*
    Map:
        |--Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的，JDK1.0，效率底
        |--HashMap:底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的，JDK1.2，效率高
        |--TreeMap:底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序

Map和Set很想
其实Set底层就是使用了Map集合
*/

//java基础视频第16天-03-集合（Map共性方法）
import java.util.*;
class MapDemo2 
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();
        //增
        sop(map.put("1","abc1"));    //返回null，
        sop(map.put("1","abc4"));    //当键相同的时候，新的值会替代旧的值，并返回旧的值
        map.put("2","abc2");
        map.put("3","abc3");
        map.put(null,null);        //null可以为HashSet的键值对
        //打印
        sop(map);
        //查
        sop(map.get("1"));
        sop(map.get("22"));        //如果没有这个键，则返回null
        //删
        sop(map.remove("2"));    //如果存在这个键的值，删除之后返回删除的值
        sop(map.remove("22"));    //如果不存在这个键的值，则返回null
        //判
        sop(map.isEmpty());
        sop(map.containsValue("abc3"));
        sop(map.containsKey(null));

        //打印出value值
            Collection<String> coll = map.values();        //values()返回来的值是一个集合Collection
            sop(coll);

    }
    public static void sop(Object o)
    {
    System.out.println(o);
    }
}

//java基础视频教程第16天-04-集合(Map-keySet)
/*
    第一种方法：
    通过keySet打印出HashMap中的键值对
*/
import java.util.*;
class MapDemo3
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1","abc1");
        map.put("2","abc2");
        map.put("3","abc3");
        map.put("4","abc4");
        map.put("5","abc5");
        Set<String> keyset = map.keySet();        //keySet()返回的是set的集合，集合中都是key的
        Iterator<String> i = keyset.iterator();    //通过Set中的迭代器取出键元素，然后通过get(key)获取值
        while(i.hasNext())
        {
            String s = i.next();
            sop(s+"->"+map.get(s));
        }
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}

//java基础视频教程第16天-05-集合（Map-entrySet）
import java.util.*;
class MapDemo4
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1","abc1");
        map.put("2","abc2");
        map.put("3","abc3");
        map.put("4","abc4");
        map.put("5","abc5");
        Set<Map.Entry<String,String>> s= map.entrySet();            //entrySet()返回的是映射关系类型，相当于结婚证，把映射关系存入Set集合中
        Iterator<Map.Entry<String,String>> i = s.iterator();        //然后用Set集合中的迭代器遍历出映射类型
        while(i.hasNext())
        {
            Map.Entry<String,String> m = i.next();        //映射类型
            sop(m.getKey()+":"+m.getValue());            //映射关系也有自己的方法取出key和value
        }

    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}
/*
    Map.Entry其实Entry也是一个接口，它是Map接口中的一个内部接口
    如下：

interface Map
{
    public static interface Entry            //能在接口上加static表示这个接口是成员位置上
    {
        public abstract Object getKey();
        public abstract Object getValue();
    }
}
class HashMap implements Map
{
    class Hahs implements Map.Entry
    {
        public Object getKey(){}
        public Object getValu(){}
    }
}

*/

//java基础视频教程第16天-06-集合（Map练习）
/*
    用HashMap存Person对象
    学生属性：姓名，年龄
    注意：姓名和年龄相同视为同一个学生
    保证学生的唯一性

    1.描述学生
    2.定义map容器，将学生作为键，地址作为值，存入
    3.两种方式获取map集合中的元素
*/
import java.util.*;
class Person implements Comparable<Person>                //当集合中要创建多个这样的对象时，放在那个集合不确定，所以实现Comparable和重写hashCode和equals
{
    private String name;
    private int age;
    Person(String name , int age)
    {
        this.name = name;
        this.age = age;
    }
    public int compareTo(Person p)
    {
        int num = new Integer(this.age).compareTo(new Integer(p.age));
        if(num==0)
            return this.name.compareTo(p.name);
        return num;
    }
    public int hashCode()
    {
            return this.name.hashCode()+this.age*34;    
    }
    public boolean equals(Object o)                //此处的equals不能用泛型，因为它是继承与Object，没有泛型
    {
        if(!(o instanceof Person))
            throw new ClassCastException("传入的值不是Person类型");
        Person p = (Person)o;
        return this.name.equals(p.name) && this.age == p.age;

    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public String toString()
    {
        return(name+":"+age);
    }
}
class MapTest 
{
    public static void main(String[] args) 
    {
        HashMap<Person,String> h = new HashMap<Person,String>();
        h.put(new Person("abc1",19),"beijing");
        h.put(new Person("abc1",19),"sichuan");        //当键key相同时，会替换前者
        h.put(new Person("abc2",20),"tianjing");
        h.put(new Person("abc3",21),"nanjing");
        //第一种方法
        Set<Person> s = h.keySet();
        Iterator<Person> i = s.iterator();
        while(i.hasNext())
        {
            Person p = i.next();
            sop(p.getName()+":"+p.getAge()+":"+h.get(p));
        }
        //第二种方法
        Set<Map.Entry<Person,String>> st = h.entrySet();
        Iterator<Map.Entry<Person,String>> it = st.iterator();
        while(it.hasNext())
        {
            Map.Entry<Person,String> m = it.next();
            sop(m.getKey()+"---"+m.getValue());
        }

    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}

//java基础视频教程第16天-07-集合（ThreeMap练习）
/*
    需求：对人对象的年龄进行升序排序

    因为数据时以键值对形式存在的
    所以套使用可以排序的Map集合。TreeMap
*/
//会自动载入上一张的person.class
import java.util.*;
class MapTest2
{
    public static void main(String[] args) 
    {
        TreeMap<Person,String> t = new TreeMap<Person,String>(new Comp());
        t.put(new Person("abc2",22),"tianjing");
        t.put(new Person("abc1",21),"beijing");
        t.put(new Person("abc3",23),"shanghai");
        t.put(new Person("abc3",23),"wuhan");        //当Key一样的时候，后面的值覆盖前面的值
        t.put(new Person("abc4",24),"sichuan");
        Set<Map.Entry<Person,String>> s = t.entrySet();
        Iterator<Map.Entry<Person,String>> i = s.iterator();
        while(i.hasNext())
        {
            Map.Entry<Person,String> m = i.next();
            sop(m.getKey()+":"+m.getValue());
        }
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}
class Comp implements Comparator<Person>
{
    public int compare(Person p1,Person p2)
    {
        int num = p1.getName().compareTo(p2.getName());
        if(num==0)
        {
            return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        }
        return num;
    }
}

//java基础视频教程第16天-08-集合（TreeMap练习-字母出现的次数）
/*
    练习：
    "sdfgzxcvasdfxcvdf"获取该字符串的字母出现的次数
    打印如此结果：a(1)c(2)

    思路：
    1.首先把字符串变成数组
    2.然后把数组中的每个字符作为Key去查询TreeMap()集合中是否有这个值，如果没有就会返回null，则把这个key加入到TreeMap(),并给它存一个value1，如果集合中有这个值，则累积他的value值
    3.最后是打印出这个集合
*/
import java.util.*;
class MapTest3
{
    public static void main(String[] args) 
    {
        sop(getChar("sdfgzxf.c.va,?sd/fxcvdf"));
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
    
    public static String getChar(String s)
    {
        
        char[] arr = s.toCharArray();
        TreeMap<Character,Integer> t = new TreeMap<Character,Integer>();            //集合中泛型只能是引用数据类型
        int count = 0;                        //count定义在for外面只开辟一次空间
        for (int x=0;x<arr.length;x++)        //分析：我拿遍历出来的字符作为key去到TreeMap集合中去查询有没有这个键，没有就把这个键加入到集合中去，并把value初始化为1，如果有这个键则返回来是它对应的value值，value值就是代表多个这个字符
        {
            //int count = 0;                        //count定义在for循环里面，每次循环都会在栈内存中开辟空间，然后释放空间    
            if(!(arr[x]>='a' && arr[x]<='z' || arr[x]>='A' && arr[x]<='Z'))            //不是a-z或者A-Z都就继续循环
                continue;
            Integer value = t.get(arr[x]);        //集合当中都是装的对象，所以这里的value类型是Integer而非int
            
            if(value!=null)
                count = value;                    //count是int类型，value是Integer类型，能够赋值吗？？？？？？？？
                count++;                            
            t.put(arr[x],count);                //由于key值是Character,它实现了Comparable,具有比较性，所以存入的时候就有默认的自然排序
                count =0;                        //如果把count定义在for外面每次循环完要清零
            
            /*
            if(value==null)                        //注释的这部分是第一种方法塞选出t，上面那种方法更简洁
                t.put(arr[x],1);
            else
                t.put(arr[x],value+1);            
            */
        }
        sop(t);
        Set<Map.Entry<Character,Integer>> st = t.entrySet();            //entrySet返回的是映射关系类型，用Set集合存放映射关系类型
        Iterator<Map.Entry<Character,Integer>> it = st.iterator();        //然后用Set中的迭代器跌倒出关系类型
        StringBuilder sb = new StringBuilder();
        while(it.hasNext())
        {
            Map.Entry<Character,Integer> m = it.next();                //映射关系类型有自己取出key和value的方法
            sb.append(m.getKey()+"(").append(m.getValue()+")");        //可以改成sb.append(m.getKey()+"("+m.getValue()+")");
        }
        
        return sb.toString();
    }
}

//java基础教程第16天-09-集合（Map扩展）
import java.util.*;
class Student
{
    private String id;
    private String name;
    Student(String id,String name)
    {
        this.id = id;
        this.name = name;
    }
    public String getId()
    {
        return id;
    }
    public String getName()
    {
        return name;
    }
}
class MapDemo6
{
    public static void main(String[] args) 
    {
        HashMap<String,ArrayList<Student>> czbk = new HashMap<String,ArrayList<Student>>();            //List是抽象的，无法实例化
        ArrayList<Student> yure = new ArrayList<Student>();            //第二步还有些写不来
        ArrayList<Student> jiuye = new ArrayList<Student>();
        czbk.put("yure",yure);
        czbk.put("jiuye",jiuye);
        yure.add(new Student("01","wangxiaoming"));
        yure.add(new Student("02","zhangmuzi"));
        jiuye.add(new Student("01","wangxiaogang"));
        jiuye.add(new Student("02","haohaogan"));
        
        /*
        //非方法打印
        Iterator<String> i = czbk.keySet().iterator();
        while(i.hasNext())
        {
            String s = i.next();
            ArrayList<Student> l = czbk.get(s);
            Iterator<Student> it = l.iterator();
            while(it.hasNext())
            {
                Student st = it.next();
                sop(st.getId()+"---"+st.getName());
            }
        }
        */

    getValue(czbk);            //此处也可以先遍历出班级，然后用方法遍历出id和name
    }
    public static void getValue(HashMap<String,ArrayList<Student>> czbk)
    {
        Iterator<String> i = czbk.keySet().iterator();
        while(i.hasNext())
        {
            String s = i.next();
            ArrayList<Student> l = czbk.get(s);
            Iterator<Student> it = l.iterator();
            while(it.hasNext())
            {
                Student st = it.next();
                sop(st.getId()+"---"+st.getName());
            }
        }
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }

    
}

//java基础教程第16天-09-集合（Map扩展）
import java.util.*;
class MapDemo5 
{
    public static void main(String[] args) 
    {
        
        HashMap<String,String> yure  = new HashMap<String,String>();
        yure.put("01","zhangdadan");
        yure.put("02","maxiaoji");
        HashMap<String,String> jiuye = new HashMap<String,String>();
        jiuye.put("02","shahaha");
        jiuye.put("01","liuxiaoqi");
        HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();        //为什么要用HashMap，不用其它的,因为是这是映射     //注意大的嵌套放在后面，不然读不到小圈里面的
        czbk.put("yure",yure);            //注意嵌套关系
        czbk.put("jiuye",jiuye);
        

        /*
        //非方法打印出嵌套的值
        Iterator<String> i = czbk.keySet().iterator();  //注意keySet()的大小写
        while(i.hasNext())
        {
            String key = i.next();
            HashMap<String,String> value = czbk.get(key);  
                Iterator<String> it = value.keySet().iterator();

            while(it.hasNext())
            {
                String id = it.next();
                sop(id +"---"+value.get(id));
            }
        }
        */
        getValue(czbk);                    //此处也可以先遍历出班级，然后用方法遍历出id和name
    }
    //通过方法打印出嵌套的值
    public static void getValue(HashMap<String,HashMap<String,String>> shool)        //方法中传的参数泛型要注意，
    {
        Iterator<String> i = shool.keySet().iterator(); 
        while(i.hasNext())
        {
            String key = i.next();
            HashMap<String,String> value = shool.get(key);  
                Iterator<String> it = value.keySet().iterator();

            while(it.hasNext())
            {
                String id = it.next();
                sop(id +"---"+value.get(id));
            }
        }
    }
    
    public static void sop(Object o)
    {
        System.out.println(o);
    }
    
}

 

//java基础视频教程第17天-11-集合（Collections-max）
/*
    集合框架的工具类，Collections用于对List集合的排序
    public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
    public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)    //传入自己写的比较器
*/
import java.util.*;
class CollectionsDemo
{
    public static void main(String[] args) 
    {
        getSort();
    }
    public static void getSort()
    {
        List<String> l = new ArrayList<String>();
        l.add("cc");
        l.add("xxxxxx");
        l.add("cc");        //由于是数组结构，所以可以允许元素重复，因为有索引
        l.add("ddd");
        l.add("zzzzz");
        l.add("a");
        sop(l);
        Collections.sort(l);                //按照自然顺序排集合
        sop(l);
        Collections.sort(l,new Comp());            //传入比较器，通过长度排序
        sop(l);
        String max = Collections.max(l);        //去最大值，比较的是字符的asicc码
        sop(max);
        String maxLenth = Collections.max(l,new Comp());        //传入一个长度比较器，按照长度比较
        sop(maxLenth);
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}
class Comp implements Comparator<String>        
{
    public int compare(String s1,String s2)        //要想这里不在是Object，就需要泛型
    {
        if(s1.length()>s2.length())
            return 1;
        if(s1.length()<s2.length())
            return -1;
        return s1.compareTo(s2);
    }
}

 

//java基础视频教程第17天-10-集合(collection-sort)
/*
    CollectionsDemo是用于操作集合的工具类
    它的方法都是静态的，其中一个sort可以对List集合排序，因为List里面没有直接排序的方法
    public static <T extends Comparable<? super T>> void sort(List<T> list)，自然排序，传入过来的参数必须具备比较性，所以才继承Comparable，而Comparable又有自己的泛型，所以加上<? super T>

    public static <T> void sort(List<T> list, Comparator<? super T> c) ,通过传递一个比较器，就可以不用原来的自然排序功能了
*/
import java.util.*;
class CollectionsDemo
{
    public static void main(String[] args) 
    {
        List<String> l = new ArrayList<String>();
        l.add("cc");
        l.add("xxxx");
        l.add("cc");        //由于是数组结构，所以可以允许元素重复，因为有索引
        l.add("ddd");
        l.add("zzzzz");
        l.add("a");
        sop(l);
        Collections.sort(l);
        sop(l);
        Collections.sort(l,new Comp());            //传入比较器，通过长度排序
        sop(l);
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}
class Comp implements Comparator<String>        
{
    public int compare(String s1,String s2)        //要想这里不在是Object，就需要泛型
    {
        if(s1.length()>s2.length())
            return -1;
        if(s1.length()<s2.length())
            return 1;
        return s1.compareTo(s2);
    }
}

//java基础视频教程第17天-12-集合（Collections-binarySearch）
/*
    public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
    public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)
    用来查找有序集合中的特定对象的
*/
import java.util.*;
class CollectionsDemo2 
{
    public static void main(String[] args) 
    {
        List<String> it = new ArrayList<String>();
        it.add("aaaaa");
        it.add("cccc");
        it.add("ddd");
        it.add("ee");
        it.add("f");
        Collections.sort(it);
        sop(it);
        int index = Collections.binarySearch(it,"aaaaa");        //查找指定的字符，查找前对集合进行升序排序，如果元素存在则返回元素的下角标
        sop(index);
        
        int index1 = Collections.binarySearch(it,"g");    //如果查找的元素没有，则会返回（-插入点-1）返回-7，那么ee就该排在第6个的位置上[aaaa, aaa, bbb, cc, dd, e]
        sop(index1);
        Collections.sort(it,new Comp());
        sop(it);
        int index2 = Collections.binarySearch(it,"ss",new Comp());    //按照传入的比较器比较长度排序，ss应该排在第三位，所以返回的是（-3-1），
        sop(index2);
        
        int num = halfSearch(it,"g");
        sop(num);
        int num1 = halfSearch1(it,"f",new Comp());
        sop(num1);
    }
    public static int halfSearch(List<String> it,String key)        //二分查找
    {
        int min=0,max=it.size()-1,mid;        //分析：二分查找是通过要查找的key与中间值比较，当key比中间值mid大那么min就向右移min=mid+1,如果
        while(max>=min)                                    //key比中间值小那么max就向左移max=mid-1，如果key与中间值相等，表示key与中间值相同，就返回key的位置
        {                                                //以上的前提条件是max>=min
            mid =(min+max)>>1;                    //相当于除2
            int num = key.compareTo(it.get(mid));            //此处比较的是字符码的大小
            if(num>0)
                min = mid+1;                            //min=0,max = 4,mid =2,it.get(2)="ddd",ee.conpareTo(ddd)<1,max=1
            else if(num<0)
                max = mid-1;
            else
            return mid;

        }                                                
        return min/*-min-1*/;        //如果返回为-min-1则就相当于binarySearch
    }
    public static int halfSearch1(List<String> it,String key,Comparator<String> comp)    //按照长度查询    //相当于在binarySearch中插入自定义比较器
    {
        int min=0,max=it.size()-1,mid;        
        while(max>=min)                                
        {                                                
            mid =(min+max)>>1;                    
            int num = comp.compare(key,it.get(mid));            //关于这点仔细研究下
            if(num>0)
                min = mid+1;                            
            else if(num<0)
                max = mid-1;
            else
            return mid;

        }                                                
        return min/*-min-1*/;        
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}
class Comp implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        if(s1.length()>s2.length())
            return 1;
        if(s1.length()<s2.length())
            return -1;
        return s1.compareTo(s2);
    }
}

//java基础视频教程17天-13-集合（Collection-替换反转）
/*
public static <T> void fill(List<? super T> list, T obj)
public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
public static void reverse(List<?> list)
*/
import java.util.*;
class CollectionsDemo3
{
    public static void main(String[] args) 
    {
        List<String> it = new ArrayList<String>();
        it.add("aaaaa");
        it.add("cccc");
        it.add("ddd");
        it.add("ee");
        it.add("f");
        //Collections.fill(it,"qy");    //将集合中的元素全部替换为指定的对象
        
        sop(it);
        Collections.replaceAll(it,"f","x");        //f是旧值，x是新值，其实这个方法就相当于List中的set(get(g),x)
        sop(it);
        sop(fillDemo(it,"cccc","ee"));            
        Collections.reverse(it);                //反转List集合
        sop(it);
    }
        /*
            练习：fill方法可以将list集合中的元素替换为指定的元素，现在要求将list集合中部分袁术替换为指定的元素
            分析：fill可以将List集合中的元素都替换成指定的元素，现在我要求将List集合中部分元素替换成指定元素，那么必须由其实位置start和结束位置end
            如何取出，start到end位置之间的元素呢,比如我现在要替换cccc到ee之间的元素
        */

    public static List<String> fillDemo(List<String> it ,String start,String end)
    {
        int x =it.indexOf(start);
        int y =it.indexOf(end);
        List<String> i=it.subList(x,y+1);        //subList()方法取头不娶尾，所以y要加1
        Collections.fill(i,"qy");
            return it;
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}

//java基础视频教程第17天-14-集合（Collection-reverseOrder）
/*
    public static <T> Comparator<T> reverseOrder()        //返回的是比较器，这个比较器可以强行逆转集合中元素的自然排序
    public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)        //返回还是比较器，这个比较器可以把传入的比较器反转
*/
import java.util.*;
class CollectionsDemo4
{
    public static void main(String[] args) 
    {
        TreeSet<String> it = new TreeSet<String>(Collections.reverseOrder(new LenthComp()));    //强制反转长度比较器。    
        it.add("aaaaa");
        it.add("ddd");
        it.add("cccc");
        it.add("ee");
        it.add("me");
        it.add("f");
        sop(it);
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}
/*
相当于Collections.reverseOrder() 反序排序
class StrComp implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        return s2.compareTo(s1);            
    }
}
*/
class LenthComp implements Comparator<String>        
{
    public int compare(String s1,String s2)
    {
        int num =  new Integer(s1.length()).compareTo(new Integer(s2.length()));    //要把int转换成Integer才能用Integer的方法compareTo        
        if(num ==0)
        return s1.compareTo(s2);
        return num;
    }
}

//java基础视频教程第17天-15-集合（Collection-SynList）
/*
    这章主要讲解synchronized的一系列方法，它可以将非同步的系列集合转换成同步的结合
    public static <T> Collection<T> synchronizedCollection(Collection<T> c)
    public static <T> List<T> synchronizedList(List<T> list) 
    public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
    public static <T> Set<T> synchronizedSet(Set<T> s)
    然后就是
    public static void reverse(List<?> list)    //反转有序的列表集合，记住是有序的
    public static void swap(List<?> list,int i,int j)    //置换列表集合集合中任意两个元素的位置
    public static void shuffle(List<?> list)        //随机的置换列表中的元素位置,比如用于洗牌，初始化骰子什么的
*/
import java.util.*;
class CollectionsDemo5
{
    public static void main(String[] args) 
    {
        List<String> it = new ArrayList<String>();
        it.add("abcde");
        it.add("bcd");
        it.add("cd");
        it.add("d");
        sop(it);
        Collections.reverse(it);
        sop(it);
        Collections.swap(it,1,2);            //置换的只是位置，所以这里的swap()只能用于置换有序列表
        sop(it);
        Collections.shuffle(it);
        sop(it);

    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}

//java基础视频教程第17天-16-集合(Arrays)
/*
    本课主要讲了Arrays中的方法，这个类主要操作数组方法如下
    binarySearch,二分查找数组中的元素，大概有三种形式，分别是查找指定的key，查找指点范围的key，以及传入比较器查找key
    copyOf,复制指定长度的数组
    copyOfRange，复制指定的长度的元素组成一个新的数组，从那到那，不包含尾
    deepEquals,深度比较
    equals,比较
    fill，替换数组中个值，也可以替换指定范围的值
    hashCode
    sort，排序，还可以让指定范围排序
    toString，将数组变为字符串

    最特别的方法
    asList()：将数组变成list集合
    注意：对于把数组转换成集合的好处是便于用集合的方法区操作数组的元素，但是却不能用增删方法操作


*/
import java.util.*;            //不要忘记Arrays也是util包中的类
class ArraysDemo
{
    public static void main(String[] args) 
    {
        int[] arr = {1,2,3,4,5};
        String s =Arrays.toString(arr);                //将数组转换成字符串
        sop(s);
        asList();
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
    public static void asList()
    {
        int[] arr = {1,2,3,4,5};
        Integer[] num = {1,2,3,4,5};
        List<int[]> l = Arrays.asList(arr);        //当数组类型是基本数据类型时，则只会把这个数组作为一个元素存入List集合中，类型为int[],打印的只是一个元素的哈希值
        List<Integer> i = Arrays.asList(num);    //当数组类型不是基本数据类型时，则会把数组中的每个元素存到List集合中，打印出集合中的每个元素
        sop(l);
        sop(i);
        String[] s = {"aa","ba","ca","ea"};
        List<String> list= Arrays.asList(s);
        //t.add("d");                        //对于转换成的列表不能添加和删除数据，否则运行时出异常UnsupportedOperationException
        //t.remove(2);
        sop(list);
        sop("contains:"+list.contains("ca"));        //list里面没有contains方法，用的是Arraylist中的方法，所以，父类调用子类方法用的就是子类的
        sop(searchKey(s,"e"));                        //相当于contains
    }
    public static boolean searchKey(String[] arr,String key)        
    {
        for (int x=0;x<arr.length;x++)
        {
            if(arr[x].equals(key))
                return true;
        }
        return false;
    }
}

//java基础视频教程第17天-17-集合（集合转成数组）
/*
    本课主要讲解了Collection中的toArray()方法，将集合变成数组
    将集合变成数组时为了禁止对集合进行增删，禁止操作集合中的元素
    <T> T[] toArray(T[] a)        //传递的数组要多长，最好就是集合的长度
    Object[] toArray()
*/
import java.util.*;
class CollectionToArray 
{
    public static void main(String[] args) 
    {
        
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc");
        al.add("cde");
        al.add("bcd");
        al.add("def");
        sop(al);
        String[] s = al.toArray(new String[1]);  //传递一个个数小于集合元素的个数的数组时，则系统会自动建立一个集合元素个数的数组装下这些元素
        sop(Arrays.toString(s));
        String[] r = al.toArray(new String[6]);     //当传递一个个数大于集合元素个数的数组时，过多的个数会用null代替
        sop(Arrays.toString(r));    
        String[] arr = al.toArray(new String[al.size()]);        //传递一个个数等于集合中元素个数的数组恰恰好
        sop(Arrays.toString(arr));                //Arrays.toString(arr)上一章才学的，这就忘记用了，用少了，凡是数组就应该想到Arrays里面的方法
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}

//java基础视频教程第17天-18-集合(增强for循环)
/*
    本节课主要学习了高级for循环，以及高级for循环和迭代器的区别，还有高级for循环和传统for循环的区别，以及map中如何运用高级for循环
    高级for循环是迭代器的建议替代，它来自于Collection的爹Iterable(可迭代)框架提供的foreach功能

    高级for循环格式
    for(泛型类型 变量名:要遍历的Collection集合或数组)
        打印出变量名

    高级for循环只能对集合进行遍历获取，但是不能对集合进行操作
    而迭代器可以对集合中的元素进行remove，另外ListIterator中的可以对集合中的元素进行很多操作
    高级for循环与传统for循环最大的区别在于，高于for循环需要传递要遍历的集合或者数组
    遍历数组通常用传统的for循环，因为传统的for循环可以提取数组的角标，便于操作数组
*/
import java.util.*;
class ForEachDemo
{
    public static void main(String[] args) 
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc");
        al.add("bcd");
        al.add("cde");
        al.add("ecf");
        /*
        迭代器方式
        Iterator<String> it = al.iterator(); 
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        */
        for(String s:al)        //迭代器的替换，因为是JDK5之后才出现的高级for循环，所以必须由泛型，所以这个程序中的ArrayList要加上泛型
            //s="KK";                //高级for循环的循环原理是这里的s在移动，当我改变s值时，其实是没有改变集合的
            //sop(al);
            sop(s);
        for (Iterator<String> it = al.iterator();it.hasNext() ; )    //传统的for循环迭代集合，外国人常用
        {
            System.out.println(it.next());
        }


        String[] arr ={"a","b","c","d"};        //高级for循环也可以迭代数组
        for(String t:arr)
            sop(t);

        for (int x=0;x<arr.length;x++)            
        {
            if(x!=arr.length)            //通常遍历数组用传统for循环，因为，传统for循环可以提取数组元素的角标
            System.out.println(arr[x]);
        }
    
    //HashMap如何运用高级for循环，先keySet或者entrySet，然后再用高级for循环
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"abc");
        hm.put(2,"bcd");
        hm.put(3,"cde");
         Set<Integer> i = hm.keySet();
        for(Integer t:i)
            sop(hm.get(t));
        /*
        Set<Map.Entry<Integer,String>> st = hm.entrySet();
        for(Map.Entry<Integer,String> m:st)
        */
        for(Map.Entry<Integer,String> m:hm.entrySet())    //上面的简写
            sop(m.getKey()+"---"+m.getValue());
        
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }


}

//java基础视频教程第17天-19-集合（可变参数）
/*
    这节课主要讲解了可变参数，最重要点是可变参数的注意事项：必须把可变参数放在参数类表的最后面（左边）
    可变参数是为了简化传统方式的传递数组的形式，少了new数组的这个步骤
*/
class ParamDemo
{
    public static void main(String[] args) 
    {
        //show(4);            //传统的方式传递参数
        //show(4,3);        //传统的方式传递参数


        //int[] arr ={1,3,4,67,8};    //传统方式改进的方法就是把数组当做参数传入,但是还是需要new数组，
        //show(arr);    
        show();
        show(1,2454,66,6);
        //show1(1,2,3,5,6,"hahh");        //如果有其它的参数类则应该房子可变参数的后边，这样写是错误的 
        show1("jja",1,12,5,6);
    }
    /*
    传统的方式传递多个参数需要不断重写一个方法，
    public static void show(int a)    //传统的方式传递参数
    {
        sop(a);
    }
    public static void show(int a,int b)    //传统的方式传递参数
    {
        sop(a+b);
    }
    */
    /*
    public static void show(int[] arr)    //传统方式改进的方法就是把数组当做参数传入,但是还是需要new数组，
    {
        sop(a+b);
    }
    */
    public static void show(int... arr)        //新特性，JDK1.5之后出现的可变参数是基于数组的形式的简化，和传递数组对比，这个少了new数组的麻烦
    {
        sop(arr.length);
    }
    /*
    public static void show1(int... arr,String s)//在可变参数中有其它的参数则应该把其他的参数放在最前面，此种写法是错误的
    {
        sop(arr.length);
    }
    */
    public static void show1(String s,int... arr)//在可变参数中有其它的参数则应该把其他的参数放在最前面，此种写法是对的
    {
        sop(arr.length);
    }
    public static void sop(Object o)        
    {
        System.out.println(o);
    }
}

//java基础视频教程第17天-20-集合（静态导入）
/*
    本节课主要讲解了静态导入，静态导入就是导入一个类中的所有静态成员，简化了代码量
    像java.util包中的Arrays和Collections等等中的方法都是静态的，就可以静态导入
    
    但是静态导入必须注意一个问题，就是当这个类有继承的时候，如果它的父类有相同的方法时，就
    必须明确时谁的方法，否则会出错

    注意一点，导入的中没有写static就是导入的类，如果导入中写了static则是导入的某个类的所有静态成员
*/
import java.util.*;        //java.util中的所有类
import static java.util.Arrays.*;    //导入Arrays这个类中的所有静态成员,不要忘记加上static
import static java.lang.System.*;    //导入System这个类中的所有静态成员，可以不写System了
class StaticDemo
{
    public static void main(String[] args) 
    {
        int[] arr = {3,7,6,1};
        //Arrays.sort(arr);        //自动排序,如果不静态导入就这样写
        sort(arr);                //静态导入，可以省略Arrays
        //sop(toString(arr));        //将数组以字符串形式形式打印，此处要注意，由于类StaticDemo继承了Object，而Object中也有toString()方法，只是没有传参数，如果这里把Array去掉，就会默认是Object的，但是Object中没有传入参数，所以这里会出错
        sop(Arrays.toString(arr));            //此处绝对要注意，当一个类中调用的国歌类的共同方法时一定要注明是谁的方法
    }
    public static void sop(Object o)
    {
        out.println(o);                //看到没得，没写该死的System
    }
}