前言

java学习之路—–>基础复习

内容

1.集合

1.1 集合的类型和各自的特性

---|Collection: 单列集合
    ---|List: 有存储顺序, 可重复

        ---|ArrayList: 
        数组实现, 查找快, 增删慢
        由于是数组实现,在增和删的时候会牵扯到数组增容,以及拷贝元素.所以慢。
        数组是可以直接按索引查找,所以查找时较快。

        ---|LinkedList:    
        链表实现, 增删快, 查找慢
        由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记
        住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高但查询时需要一
        个一个的遍历, 所以效率较低

        ---|Vector:    
        和ArrayList原理相同, 但线程安全, 效率略低

    ---|Set: 无存储顺序, 不可重复

        ---|HashSet: 
        线程不安全，存取速度快。底层是以哈希表实现的。

        ---|TreeSet   
        红-黑树的数据结构，默认对元素进行自然排序（String）。如果在比较的时候两
        个对象返回值为0，那么元素重复。

1.2 遍历集合

遍历集合的几种方式

    1. 使用迭代器Iterator的方式。
    2. 使用增强for循环的方式。
    3. 如果有下标，则可以使用下标的方式。

遍历数组
    public static void main(String[] args) {
    // 遍历数组：
    String[] arr = new String[] { "xx", "yy", "zz" };

    // 1，增强的for循环
    for (String elt : arr) {
        System.out.println(elt);
    }

    // 2，下标的方式
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
 }

遍历List
    public static void main(String[] args) {
        // 遍历List：
        List<String> list = new ArrayList<String>();
        list.add("aa");
        list.add("bb");
        list.add("cc");

        // 1，增强的for循环
        for (String elt : list) {
            System.out.println(elt);
        }

        // 2，下标
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 3，迭代器
        for (Iterator<String> iter = list.iterator(); iter.hasNext();){
            String elt = iter.next();
            System.out.println(elt);
        }
    }

遍历Set
    public static void main(String[] args) {
        // 遍历Set：
        Set<String> set = new HashSet<String>();
        set.add("dd");
        set.add("ee");
        set.add("ff");

        // 1，增强的for循环
        for (String elt : set) {
            System.out.println(elt);
        }

        // 2，迭代器
        for(Iterator<String> iter = set.iterator(); iter.hasNext() ; ){
            String elt = iter.next();
            System.out.println(elt);
        }
    }

遍历Map
    public static void main(String[] args) {
        // 遍历Map：
        Map<String, String> map = new HashMap<String, String>();
        map.put("aa", "xx");
        map.put("bb", "yy");
        map.put("cc", "zz");

        // 1，增强的for循环（Entry集合）
        for (Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry);
        }

        // 2，增强的for循环（Key集合）
        for(String key : map.keySet()){
            System.out.println(key + " = " + map.get(key));
        }

        // 3，遍历值的集合
        for(String value : map.values()){
            System.out.println(value);
        }
     }

2.泛型

2.1 泛型出现原因

存入的是特定的对象,取出的时候是Object对象,需要强制类型转换,可能诱发类型转换异常。无法控制存入的是什么类型的对象,取出对象的时候进行强转时可能诱发异常。而且在编译时期无法发现问题。

虽然可以再类型转换的时候通过if语句进行类型检查(instanceof),但是效率较低。(例如吃饭的时候,还需要判断米饭里有没有沙子,吃饭效率低)。可以通过给容器加限定的形式规定容器只能存储一种类型的对象。

就像给容器贴标签说明该容器中只能存储什么样类型的对象，所以在jdk5.0后出现了泛型。

2.2 泛型作用

将运行时的异常提前至编译时发生。
获取元素的时候无需强转类型，就避免了类型转换的异常问题

2.3 泛型使用细节

细节一：  声明好泛型类型之后,集合中只能存放特定类型元素
        public class Demo6 {
        public static void main(String[] args) {
            //创建一个存储字符串的list
            ArrayList<String> arr=new ArrayList<String>();
            arr.add("gz");
            arr.add("itcast");
            //存储非字符串编译报错.
            arr.add(1);
        }
      }
细节二：  泛型类型必须是引用类型
        public class Demo6 {
        public static void main(String[] args) {
            // 泛型类型必须是引用类型,也就是说集合不能存储基本数据类型
            // ArrayList<int> arr2=new ArrayList<int>();
            // 使用基本数据类型的包装类
            ArrayList<Integer> arr2 = new ArrayList<Integer>();
        }
      }
细节三:   使用泛型后取出元素不需要类型转换.
        public class Demo6 {
            public static void main(String[] args) {

                ArrayList<String> arr = new ArrayList<String>();
                arr.add("gzitcast");
                arr.add("cditcast");
                arr.add("bjitcast");
                //使用泛型后取出元素不需要类型转换.
                String str=arr.get(0);
                System.out.println();
        }
      }

创建对象的时候要指定泛型的具体类型
创建对象时可以不指定泛型的具体类型(和创建集合对象一眼)。默认是Object，例如我们使用集合存储元素的时候没有使用泛型就是那么参数的类型就是Object
类上面声明的泛型只能应用于非静态成员函数，如果静态函数需要使用泛型，那么
需要在函数上独立声明。
如果建立对象后指定了泛型的具体类型，那么该对象操作方法时，这些方法只能操作一种数据类型。
所以既可以在类上的泛型声明，也可以在同时在该类的方法中声明泛型。
静态方法不可以使用类中定义的泛型

3.IO

         输入流          输出流                说明
字节流    InputStream     OutputStream    字节流是处理字节的（二进制）
字符流      Reader        Writer        字符流是处理字符的

4.多线程

4.1 启动线程方式

自定义的类继承Thread类。使用代码为new MyThread().start()
自定义的类实现Runnable接口。使用代码为
new Thread(newMyRunnable()).start

4.2 代码实现

private static int count = 100;

public static void main(String[] args) {
    // 用继承Thread类的方式启动一个线程
    new Thread() {
        public void run() {
            synchronized (StartThreadTest.class) {
                while (count > 0) {
                    count--;
                    System.out.println(Thread.currentThread() + "卖了一张票，还剩" + count);
                }
            }
        }
    }.start();

    // 用实现Runnable接口的方式启动一个线程
    new Thread(new Runnable() {
        public void run() {
            synchronized (StartThreadTest.class) {
                while (count > 0) {
                    count--;
                    System.out.println(Thread.currentThread() + "卖了一张票，还剩" + count);
                }
            }
        }
    }).start();
}

5.Junit

5.1 Junit用途

目前方法如果需要测试，都要在main函数方法上调用
目前的结果需要我们人工对比

5.2 Junit细节

绿条表示通过，红条表示失败
在测试方法上用@Test
点击类测试，则测试所有类中的test方法；其他类似
@Test不能是静态的，且不能有形参
如果测试一个方法的时候需要准备测试的环境或者是清理测试的环境，可以使用@before/beforeclass @after/afterclass

5.3 Junit使用规范

一个类如果需要测试，则该类就应该对应一个测试类，测试类的命名方法为：测试类名+test
一个被测试的方法一般对应一个测试的方法，测试的方法的命名是：test+方法名

6.内省

开发框架时候，会把一些东西封装到对象中。
变态的反射
使用JAVA对象属性封装程序的数据

7.BeanUtils

解决问题：
将对象的属性数据封装到对象中
好处
1> BeanUtils设置属性的时候，如果属性书基本数据类型，BeanUtils会自动转回数据类型
2> BeanUtils设置属性值得底层也是依赖SETHUO GET方法
3> BeanUtils设置属性值，如果设置的属性是其他的引用类型的数据，需要注册一个类型转换器
操作步骤
1> 导入BeanUtils包
2> 导入LOGGING包
配置文件路径问题