Java基础12-工具类;变长参数;IO

作业解析

1. 取出整数的16进制表示形式 \u00ff

    /**
     * int2hex
     * */
    public static String int2hex(int i) {
        String str = "0x";
        char[] c = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        for(int j=28;j>=0;j=j-4) {
            str = str + c[(i>>j)&0xf];
        }
        return str;
    }
   

2. 取出整数的8进制表示形式

    /**
     * int2oct
     * */
    public static String int2oct(int i) {
        String str = "";
        char[] c = {'0','1','2','3','4','5','6','7'};
        for(int j=30;j>=0;j=j-3) {
            str = str + c[(i>>j)&7];
        }
        return str;
    }
   

3. 使用韩语字符集实现字符串编解码

    public static void main(String[] args) throws Exception {
            //使用韩语字符集实现字符串编码
            String str = "한국어";
            System.out.println(str);//한국어
   
            //utf-8编码解码
            byte[] Byte = str.getBytes("utf-8");
            System.out.println(new String(Byte,"utf-8"));//한국어
   
            //GB2312编码解码
            Byte = str.getBytes("GB2312");
            System.out.println(new String(Byte,"GB2312"));//???
   
            //EUC-KR编码解码
            Byte = str.getBytes("EUC-KR");
            System.out.println(new String(Byte,"EUC-KR"));//한국어
        }
   

4. 字符串倒序排列

    public static void main(String[] args) throws Exception {
        //字符串倒序排列
        String str = "abcd1234";
        byte[] Bytes = str.getBytes("utf-8");
        byte[] Bytes2 = new byte[Bytes.length];
        for(int i=Bytes.length-1;i>=0;i--) {
            Bytes2[Bytes.length-1-i]=Bytes[i];
        }
        System.out.println(new String(Bytes2,"utf-8"));
    }
   

5. 练习自动拆箱和装箱

    int i = 12;
    Integer ii = i;
    System.out.println(ii);//12
    int j = ii;
    System.out.println(j);//12
   

6. 实现equals方法，比较四方面要素，Student{name height weight age}

    public class Student {
        private String name;
        private int age;
        private int height;
        private int weight;
        public Student(String name, int age, int height, int weight) {
            this.name = name;
            this.age = age;
            this.height = height;
            this.weight = weight;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public int getHeight() {
            return height;
        }
        public void setHeight(int height) {
            this.height = height;
        }
        public int getWeight() {
            return weight;
        }
        public void setWeight(int weight) {
            this.weight = weight;
        }
        @Override
        public boolean equals(Object obj) {
            if(obj==this) {
                return true;
            }
            if(obj==null) {
                return false;
            }
            //精准匹配
            if(obj.getClass()==Student.class) {
                Student s = (Student)obj;
                //判断姓名
                boolean nameEqu = false;
                if(s.getName()==null) {
                    if(this.getName()==null) {
                        nameEqu = true;
                    }
                    else {
                        nameEqu = false;
                    }
                }
                else {
                    nameEqu = s.getName().equals(this.getName());
                }
   
                boolean ageEqu = false;
                if(s.getAge()==this.getAge()) {
                    ageEqu = true;
                }
                boolean heightEqu = false;
                if(s.getHeight()==this.getHeight()) {
                    heightEqu = true;
                }
                boolean weightEqu = false;
                if(s.getWeight()==this.getWeight()) {
                    weightEqu = true;
                }
                return nameEqu && ageEqu && heightEqu && weightEqu;
            }
            return false;
        }
    }
    Student s1 = new Student("s1", 10, 10, 10);
    Student s2 = new Student(null, 10, 10, 10);
    Student s3 = new Student(null, 10, 10, 10);
    Student s4 = new Student("s1", 10, 10, 10);
   
    System.out.println(s1.equals(new Student("s2", 10, 10, 10)));//false
    System.out.println(s1.equals(new Student("s1", 10, 10, 10)));//true
   
    System.out.println(s1==s1);//true
    System.out.println(s1.equals(s1));//true
   
    System.out.println(s1==s4);//false
    System.out.println(s1.equals(s4));//true
   
    System.out.println(s2==s3);//false
    System.out.println(s2.equals(s3));//true
   
    System.out.println(s1==s2);//false
    System.out.println(s1.equals(s2));//false		
   
    System.out.println(s1.equals(null));//false
   

7. 创建集合，存放10个person对象，5个Car对象，3个Bee对象，迭代集合，输出每个对象的name属性

    public class Person {
        private String name;
   
        public Person(String name) {
            super();
            this.name = name;
        }
   
        public String getName() {
            return name;
        }
   
        public void setName(String name) {
            this.name = name;
        }
    }
   
    public class Car {
        private String name;
        private int no;
   
        public Car(String name, int no) {
            super();
            this.name = name;
            this.no = no;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getNo() {
            return no;
        }
        public void setNo(int no) {
            this.no = no;
        }
    }
   
    public class Bee {
        private String name;
   
        public Bee(String name) {
            super();
            this.name = name;
        }
   
        public String getName() {
            return name;
        }
   
        public void setName(String name) {
            this.name = name;
        }
    }
   
    public static void main(String[] args) {
        List list = new ArrayList();
   
        //存放人
        for(int i=0;i<10;i++) {
            list.add(new Person("p"+i));
        }
        //存放汽车
        for(int i=0;i<5;i++) {
            list.add(new Car("c"+i,i));
        }
        //存放蜜蜂
        for(int i=0;i<3;i++) {
            list.add(new Bee("b"+i));
        }
   
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Object obj = it.next();
            //精准匹配
            if(obj.getClass()==Person.class) {
                Person p = (Person)obj;
                System.out.println(p.getName());
            }
            if(obj.getClass()==Bee.class) {
                Bee b = (Bee)obj;
                System.out.println(b.getName());
            }
            if(obj.getClass()==Car.class) {
                Car c = (Car)obj;
                System.out.println(c.getName());
            }
        }
    }
   

8. 使用Map集合实现嵌套: 操场上六个年级，每个年级有10班，每个班有60人(String)
   
   tom-x-y-n

    /**
     * 使用Map集合实现嵌套: 操场上六个年级，每个年级有10班，每个班有60人(String)tom-x-y-n
     * */
    public class MapDemo {
   
        public static void main(String[] args) {
            //定义年级
            Map<Integer, Map<Integer, Map<Integer,String>>> grades = new HashMap<Integer, Map<Integer,Map<Integer,String>>>();
            //定义班级
            Map<Integer, Map<Integer,String>> classes = null;
            for(int x=1;x<=6;x++) {
                classes = new HashMap<Integer, Map<Integer,String>>();
                grades.put(x, classes);
                //定义名单
                Map<Integer,String> names = null;
                for(int y=1;y<=10;y++) {
                    names = new HashMap<Integer,String>();
                    classes.put(y, names);
                    for(int n=1;n<=60;n++) {
                        names.put(n, "tom-"+x+"-"+y+"-"+n);
                        System.out.println("tom-"+x+"-"+y+"-"+n);
                    }
                }
            }
   
            //迭代嵌套的Map集合
            System.out.println("======使用KeySet==========");
            outMapwithKey(grades);
   
            System.out.println("======使用EntrySet========");
            outMapwithEntry(grades);
   
            System.out.println("=======使用迭代器==========");
            outMapwithIterator(grades);
   
        }
   
        /**
         * 使用key迭代
         * */
        private static void outMapwithKey(Map<Integer, Map<Integer, Map<Integer, String>>> grades) {
            //取出年级key
            Set<Integer> gradeSet = grades.keySet();
            for(Integer gradeKey : gradeSet) {
                Map<Integer, Map<Integer, String>> gradeValue = grades.get(gradeKey);
                //取出班级key
                Set<Integer> classSet = gradeValue.keySet();
                for(Integer classKey: classSet) {
                    Map<Integer, String> classValue= gradeValue.get(classKey);
                    //取出名单key
                    Set<Integer> names= classValue.keySet();
                    for(Integer name: names) {
                        String s = classValue.get(name);
                        System.out.println(gradeKey+"-"+classKey+"-"+name+":"+s);
                    }
                }
            }
        }
        /**
         * 使用条目迭代
         * */
        private static void outMapwithEntry(Map<Integer, Map<Integer, Map<Integer, String>>> grades) {
            //取出年级条目：年级id ------> 班级集合
            Set<Entry<Integer,Map<Integer, Map<Integer, String>>>> gradeEntries = grades.entrySet();
            for(Entry<Integer,Map<Integer, Map<Integer, String>>> gradeEntry: gradeEntries) {
                //依次取出每个条目的键:年级id，每个条目的值：班级条目集合
                Integer gradekey = gradeEntry.getKey();
                Map<Integer, Map<Integer, String>> classes = gradeEntry.getValue();
   
                //取出班级条目：班级id ------> 名单集合
                Set<Entry<Integer, Map<Integer, String>>> classEntries = classes.entrySet();
                for(Entry<Integer, Map<Integer, String>> classEntry : classEntries) {
                    //依次取出每个条目的键:班级id，每个条目的值：名单条目集合
                    Integer classKey = classEntry.getKey();
                    Map<Integer, String> classValue= classEntry.getValue();
                    System.out.println(gradekey+"年"+classKey+"班"+":");
                    //取出名单条目：学生id ----> 学生姓名
                    Set<Entry<Integer, String>>  namesEntries = classValue.entrySet();
                    for(Entry<Integer, String> namesEntry : namesEntries) {
                        Integer namesKey = namesEntry.getKey();
                        String namesValue =  namesEntry.getValue();
                        System.out.println(gradekey+"-"+classKey+"-"+namesKey+":"+namesValue);
                    }
                }
            }
        }
   
        /**
         * 使用迭代器迭代
         * */
        private static void outMapwithIterator(Map<Integer, Map<Integer, Map<Integer, String>>> grades) {
            //取出年级条目：年级id ------> 班级集合
            Set<Entry<Integer,Map<Integer, Map<Integer, String>>>> gradeEntries = grades.entrySet();
            //一级迭代器，迭代年级条目
            Iterator<Entry<Integer,Map<Integer, Map<Integer, String>>>> it = gradeEntries.iterator();
            while(it.hasNext()) {
                //利用一级迭代器依次取出年级id，班级集合
                Entry<Integer,Map<Integer, Map<Integer, String>>> gradeEntry= it.next();
                Integer gradeKey = gradeEntry.getKey();
                Map<Integer, Map<Integer, String>> gradeValue = gradeEntry.getValue();
   
                //二级迭代器，迭代班级条目
                Set<Entry<Integer, Map<Integer, String>>> classEntries = gradeValue.entrySet();
                Iterator<Entry<Integer, Map<Integer, String>>> it2 = classEntries.iterator();
                while(it2.hasNext()) {
                    //利用二级迭代器依次取出班级id，名单集合
                    Entry<Integer, Map<Integer, String>> classEntry= it2.next();
                    Integer classKey = classEntry.getKey();
                    Map<Integer, String> classValue = classEntry.getValue();
   
                    //三级迭代器，迭代学生名单
                    Set<Entry<Integer, String>> nameEntries = classValue.entrySet();
                    Iterator<Entry<Integer, String>> it3 = nameEntries.iterator();
                    while(it3.hasNext()) {
                        //利用三级迭代器依次取出学生id，姓名
                        Entry<Integer, String> nameEntry = it3.next();
                        Integer nameKey = nameEntry.getKey();
                        String nameValue = nameEntry.getValue();
                        System.out.println(gradeKey+"-"+classKey+"-"+nameKey+":"+nameValue);
                    }
                }
            }
        }
    }
   

9. 定义罪犯Criminal类，height(身高)/weight(体重)/blood(血型)/home(籍贯)属性。
   
   重写hashcode和equals，使用四个属性的组合进行实现。
   
   创建HashSet集合，里面存放20个Criminal对象，其中O型血2人，A型血3人，B型血4人，AB型血1人，其余血型不详。
   
   注意:hashcode()方法实现时，要求身高、体重、和血型三个属性合成一个数字，实现两两比较的高效算法。

10. 创建HashMap, Person为key, Dog 为value。
    
    存放100元素，遍历map集合，两种方式：EntrySet + KeySet

    public class Person {
        private String name;
    
        public Person(String name) {
            super();
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public int hashCode() {
            if(name!=null) {
                return name.hashCode();
            }
            else {
                return 0;
            }
        }
        @Override
        public boolean equals(Object obj) {
            if(obj==null) {
                return false;
            }
            if(obj==this) {
                return true;
            }
            if(obj.getClass()==Person.class) {
                Person p = (Person)obj;
                if(p.getName()==null) {
                    if(this.getName()==null) {
                        return true;
                    }
                    else {
                        return false;
                    }
                }
                else {
                    return p.getName().equals(this.getName());
                }
            }
            return false;
        }
        @Override
        public String toString() {
            return name;
        }
    }
    
    public class Dog {
        private String name;
        private String color;
        private String categraory;
        public Dog(String name, String color, String categraory) {
            super();
            this.name = name;
            this.color = color;
            this.categraory = categraory;
        }
        @Override
        public String toString() {
            return name+"-"+color+"-"+categraory;
        }
    }
    
    /**
     * 创建HashMap, Person为key, Dog 为value。存放100元素，遍历map集合，两种方式：EntrySet + KeySet
     * */
    public static void main(String[] args) {
        Map<Person,Dog> map = new HashMap<Person, Dog>();
        map.put(new Person("p1"), new Dog("d1","black","Jing8"));
        map.put(new Person("p1"), new Dog("d1","black","Jing8"));
        map.put(new Person(null), new Dog("d1","black","Jing8"));
        map.put(new Person(null), new Dog("d1","black","Jing8"));
        map.put(null, new Dog("d1","black","Jing8"));
        map.put(null, new Dog("d1","black","Jing8"));
        System.out.println(map.size());//没有重写hashcode()和equals()方法之前，结果为5;
        System.out.println(map.size());//重写 equals方法之后，结果仍为5;
        System.out.println(map.size());//重写hashcode和equals方法后，结果为3
    
        //存放100个条目
        map.clear();
        for(int i=0;i<100;i++) {
            map.put(new Person("p"+i), new Dog("d"+i,"black","Jing8"));
        }
    
        //使用EntrySet遍历
        Set<Entry<Person,Dog>> entries = map.entrySet();
        for(Entry<Person,Dog> entry : entries) {
            Person key = entry.getKey();
            Dog value = entry.getValue();
            System.out.println(key+":"+value);
        }
    
        //使用keySet遍历
        System.out.println("=====================");
        Set<Person> keys = map.keySet();
        for(Person key: keys) {
            Dog value = map.get(key);
            System.out.println(key+":"+value);
        }
    }
    

工具类，变长参数

1. Collections

    public class Person implements Comparable<Person> {
        private String name="";
   
        public Person(String name) {
            super();
            this.name = name;
        }
   
        public String getName() {
            return name;
        }
   
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return name;
        }
   
        @Override
        public int compareTo(Person o) {
            return this.name.compareTo(o.getName());
        }
    }
   
    public class CollectionToolDemo {
   
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            list.add("a");
            list.add("abc");
            list.add("123");
            list.add("中国");
            list.add("法国人");
            list.add("");
   
            outEle(list);//a,abc,123,中国,法国人,,
   
            //使用工具类排序
            Collections.sort(list);
            outEle(list);//,123,a,abc,中国,法国人,
   
            //取出最大值
            String max = Collections.max(list);
            System.out.println("max="+max);//max=法国人
   
            //取出最小值
            String min = Collections.min(list);
            System.out.println("min="+min);//min=
   
            //反序（非反向排序）
            Collections.reverse(list);
            outEle(list);//法国人,中国,abc,a,123,,
   
            //交换元素位置
            Collections.swap(list, 1, 3);
            outEle(list);//法国人,a,abc,中国,123,,
   
            List<Person> list2 = new ArrayList<Person>();
            list2.add(new Person("熊大"));
            list2.add(new Person("光头强"));
            list2.add(new Person("熊二"));
   
            outEle(list2);//熊大,光头强,熊二,
   
            Collections.sort(list2);//需要实现Comparable接口才可以排序
            outEle(list2);//光头强,熊二,熊大,
   
        }
        /**
         * 输出集合元素
         * */
        public static void outEle(List<? extends Object> list) {
            for(Object s: list) {
                System.out.print(s+",");
            }
            System.out.println();
        }
    }
   

2. Arrays

    public static void main(String[] args) {
        int[] a = new int[]{1,3,5,7};
        int[] a2 = copyArr(a);
        System.out.println(a2.length);//4
        int[] a3 = Arrays.copyOf(a, 2);
        System.out.println(a3);
   
        //二分法查找
        System.out.println(Arrays.binarySearch(a, 7));//3
        System.out.println(Arrays.binarySearch(a, 0,3,7));//-4
   
        //转数组为列表
        List<Integer> list = Arrays.asList(1,2,3,4);
        System.out.println(list.size());
    }
    public static int[] copyArr(int[] arr) {
        //健壮性
        if(arr==null || arr.length==0) {
            return arr;
        }
        int[] arr2 = new int[arr.length];
        for(int i=0;i<arr.length;i++) {
            arr2[i] = arr[i];
        }
        return arr2;
    }
   

3. 变长参数
   
   变长参数必须是方法的最后一个参数
   
   public void addTel(String s1, String... str); //ok
   
   public void addTel(String... str,String s1); //error

    public static void main(String[] args) {
        outArr("1","2","3","4","5");
    }
    //变长参数只能有一个，且必须是最后一位形参
    public static void outArr(String...str) {
        for(String s:str) {
            System.out.println(s);
        }
    }
   

集合内容回顾

1. list

   • ArrayList //不安全
   • LinkedList // 不安全
   • Vector // 线程安全

2. Set

   • Hashset, hashmap
   • TreeSet: 有序，Comparable
     
     排序实现方式：
     
     1）实现Comparable接口, interface Comparable{int compare}
     
     2）Comparator，对比器

3. Map

   • HashMap: key(键) - value(值) KV====Entry

   • HashTable: 线程安全

IO

1. 分类

   • 按流向：
     
     输入流 Input
     
     输出流 Output
   • 按类型：
     
     字节型: InputStream, OutputStream
     
     字符型: Reader, Writer

2. 编译时异常：需要在代码中对异常进行声明或捕获

3. FileWriter

    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("d:\\fileWriter.txt");;
            fw.write("Hello, FileWriter");
            System.out.println("over");
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            //释放资源
            try {
                if(fw!=null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
   

   • new FileWriter(String path);

   • Writer(String str);
     
     写入字符数据到流中

   • flush()
     
     清理流，将流中的数据写入目标设备上

   • close()
     
     关闭流，隐含了flush操作。流在close之后，无法再写入数据，重复关闭不会导致问题

4. FileReader
   
   不支持reset(),不支持mark(),支持skip

    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("d:\\fileWriter.txt");
        int i = 0;
        while((i=fr.read())!=-1) {
            System.out.print((char)i);
        }
        fr.close();
   
        //do...while
        System.out.println("================");
        i=-1;
        fr = new FileReader("d:\\fileWriter.txt");
        do {
            i = fr.read();
            if(i!=-1) {
                System.out.print((char)i);
            }
        }while(i!=-1);
        fr.close();
   
        //使用char[]缓冲区读取文件
        System.out.println("============");
        fr = new FileReader("d:\\fileWriter.txt");
        //fr.reset();//不支持
        //fr.markSupported();//false
        char[] buf = new char[10];
        int len = 0;
        while((len=fr.read(buf))!=-1) {
            System.out.print(new String(buf,0,len));
        }
        fr.close();
    }
   

作业

1. 描述HashMap内部实现原理

2. List Set Map区别

3. 描述HashSet和HashMap的区别

4. 编程实现文本文件的复制。合理设计程序，得到缓冲区的大小的高效区间。
   
   提示缓冲区设置1k开始，不超过10M。

5. 使用FileWriter，将1-1000000写入到文本中

6. 变长参数 + 增强for循环