JavaSE 高级 ¶

数组 ¶

简介 ¶

1. Java中数组是一种引用数据类型
2. 数组是一个容器，不属于基本数据类型，父类是Obiect
3. 数组中可以存储可以存储基本数据类型，也可以存储引用数据类型
4. 因为数组是引用数据类型，所以存储在堆中
5. 数组中存储的是Java对象，实际存储的是引用地址
6. 数组长度定义后，不能改变
7. 一维数组、二维数组、三维数组
8. 所有数组对象都有length属性
9. Java中数组要求存储在数组中元素类型必须统一；int型数组只能存储int类型数据
10. 所有数组都是拿第一个小方块（首元素）的内存地址作为整个数组的内存地址（标识）；数组在内存中存储数据时，内存地址是连续的
11. 数组中每个元素都是有下标的，从0开始到（length-1）结束
12. 好处：查找/检索某个下标上元素时，效率最高的一种结构；因为，地址连续，而且存储数据类型一样，只需要简单的运算就能找出，理解：查找下标为100的元素和查找下标为10000的元素效率一样（不是一个一个查找，算出一个内存地址，直接定位）；
13. 坏处：地址连续，所以随机删除或者增加元素，效率低，因为需要依次处理后续元素；不能存储大数据，因为很难找到一块大内存的连续空间
14. 数组扩容，先创建一个大容量数组，然后将需要扩容的数组内容一个一个拷贝到大容量数组中，然后释放原数组内存；Java中数组扩容效率较低

语法 ¶

定义语法：int[] array1；double[] array2；

初始化数组：静态初始化，int[] array={100,200,300}；动态初始化，int[] array=new int[6]，初始化6个长度的int类型数组，每个元素默认值0

Java.lang.ArrayIndexOutOfBoundsException：下标越界异常

创建时确定数组存储数据，可以静态初始化；如果不确定，动态初始化的方式分配内存空间

数组工具类 ¶

Java.util.Arrays；工具类方法大多是静态的，直接类名调用

Arrays.sort(arr)；冒泡排序，大的在右，小的在左；直接改变数组arr

binarySearch(参数列表)；二分法查找

算法 ¶

冒泡排序

循环，从第一个数据开始，依次对比，将大的放右边；循环结束后，找出一个最大的数，放到最右边；然后把剩下的数重复上面步骤

选择排序

循环一次，选出最小的，和最前面的数据交换位置；；选择排序比冒泡排序效率高，高在交换位置的次数上

二分法查找

二分法查找建立在排序的基础上；(0+arr.length-1)/2中间元素下标，和需要查找元素对比；判断出需要查找的元素在中间元素的哪一边；继续重复上述步骤，直到找到。

代码

 1/**
 2 * 冒泡排序
 3 * @param arr 排序的目标数组
 4 * @return 排序完成的数组 
 5 */
 6public static int[] maoPao(int[] arr){ //冒泡算法代码
 7    for (int i=arr.length-1;i>=0;i--){ //需要比较数字个数
 8        for (int j=0;j<i;j++){  //每个数字需要比较次数
 9            if(arr[j]>arr[j+1]){
10                int temp=arr[j+1];
11                arr[j+1]=arr[j];
12                arr[j]=temp;
13            }
14        }
15    }
16    return arr;
17}
18
19/**
20 *  选择排序
21 * @param arr 需要排序的数组
22 * @return  排序好的数组
23 */
24public static int[] xuanZe(int[] arr){ //选择排序
25    for (int i=0;i<arr.length-1;i++){
26        int min=i; //默认开始的最小值下标
27        for (int j=i+1;j<arr.length;j++){
28            if (arr[j]<arr[min]){
29                min=j; //外层循环一次，这个min应该为最小值下标
30            }
31        }
32        if (i!=min){
33            int temp=arr[i];
34            arr[i]=arr[min];
35            arr[min]=temp;
36        }
37    }
38    return arr;
39}
40
41/**
42 * 二分查找算法
43 * @param arr 需要查找的数组（必须已经排序）
44 * @param i 目标元素
45 * @return -1表示没有；其他的返回为找到元素的下标
46 */
47public static int chaZhao(int[] arr, int i) {
48    int begin=0;
49    int end=arr.length-1;
50    while (begin<=end){
51        if(arr[(begin+end)/2]==i){
52            return (begin+end)/2;
53        }else if(arr[(begin+end)/2]<i){
54            begin=(begin+end)/2+1;
55        }else if(arr[(begin+end)/2]>i){
56            end=(begin+end)/2-1;
57        }
58    }
59    return -1;
60}

异常 ¶

简介 ¶

异常，Java语言完善的异常机制，会将程序发生不正常情况在控制台打印；这种机制可以使程序员找到错误并修改，使程序更加健壮

异常抛出与捕获处理 ¶

1. 每一个异常在Java中都是以类的形式存在，每一个异常类都可以创建异常对象
2. 例：int a=7/0; //在这里会new ArithmeticException(/ by zero)异常对象，并抛出
3. Exception有两个子类，ExceptionSubClass（直接子类）编译时异常，在编写程序阶段预先进行处理，如果不处理，编译器会报错；RuntimeException运行时异常，在编写程序阶段你可以选择不处理
4. Object–>Throwable(可抛出的)；Throwable–>Error(不可处理，直接退出JVM)，Throwable–>Exception(可处理的)；Expecption下有两个分支：1.编译时异常（受控），2.运行时异常（非受控）
5. 所有异常都是在程序运行时发生的（new 异常对象），编译时异常一般发生概率比较高（生病异常，打伞预处理异常）；运行时异常（被飞机轮子砸到）
6. 如果所有异常都在编写代码时进行预处理，那么程序绝对安全，但是活得很累
7. Java中对异常处理两种方式：1.在方法声明的位置上，使用throws关键字，抛给上一级（谁调用我，就抛给谁）；2.使用try…catch语句进行异常处理
8. 如果异常一直上抛，抛给了JVM，JVM就会终止这个程序；不建议在main()方法不建议上抛，否则异常发生，程序直接报错
9. 只要异常没有捕捉，采用上抛的方式，那么该方法的后续代码不会执行
10. try…catch；catch后面的异常类型可以使用该异常类型的父类型；catch语句可以有多个，且捕捉类型从小到大；JDK8支持在catch后面的异常使用 | 连接多个异常类型，进行处理
11. 异常常用方法：
    1. Throwable msg=e.getMessage()；获取异常简单的描述信息
    2. e.printStackTrace()；打印异常追踪的堆栈信息

 1public static void main(String[] args){
 2    //int a=7/0; //在这里会new ArithmeticException(/ by zero)异常对象，并抛出
 3    /*
 4    因为doSome()方法声明位置上有：throws ClassNotFoundException
 5    我们在调用doSome()方法时，必须对这种异常进行预先处理，否则会报错如下：
 6    Unhandled exception: Java.lang.ClassNotFoundException
 7    处理异常：
 8        1.可以在main()处继续上抛（甩锅）
 9        2.可以使用try...catch进行异常捕获，然后处理（处理，结束异常）
10    * */
11    try {
12        doSome();
13    } catch (ClassNotFoundException e) { //e为new出来的异常对象的内存地址
14        System.out.println(e.getMessage()); //获取异常简单描述
15        e.printStackTrace(); //打印异常追踪的堆栈信息，采用了异步线程的方式处理
16    }
17}
18
19/**
20 * doSome()方法运行时可能会抛出ClassNotFoundException异常
21 * 这个是类没找到异常，直接父类Exception，属于编译时异常
22 * @throws ClassNotFoundException
23 */
24public static void doSome() throws ClassNotFoundException{
25    throw new ClassNotFoundException();
26//        System.out.println("doSome()方法！！！");
27}

finally ¶

1. 在finally子句中的代码是最后执行的，并且是一定会执行的，即使try语块的代码出现了异常；除非退出JVM虚拟机，否则finally语句块中内容一定会执行
2. finally语句必须和try一起出现，不能单独编写
3. finally 存在于异常处理中，最后且一定会执行的代码块；final 修饰，代表不可变的，最终的（存储在常量池）； finalize() 是Object类中一个方法，留遗言时用的，垃圾回收器负责调用

 1public static void main(String[] args) {
 2    FileInputStream fis=null; //外面声明，finally语句块与try语句块才都可以使用
 3    try {
 4        fis=new FileInputStream("123");
 5        String s=null;
 6        s.toString(); //一定会出现空指针异常，运行时异常
 7        //fis.close(); //如果在这里关闭流，可能会因为前面出异常而执行不到
 8        return; //这个return语句会在finally语句块执行后才执行
 9    } catch (FileNotFoundException e) {
10        e.printStackTrace();
11    }finally {
12        System.out.println("finally语句块执行了！！！");
13        if (fis!=null){
14            try {
15                fis.close();//这里关闭流，finallly语句块中。因此一定能执行
16            } catch (IOException e) {
17                e.printStackTrace();
18            }
19        }
20    }
21}

自定义异常

1. 编写一个类继承Exception（编译时异常）或者RuntimeException（运行时异常）
2. 提供两个构造方法，一个有参，一个无参

 1public class Test01 {
 2    public static void main(String[] args) {
 3        MyException e=new MyException("自定义异常");
 4        System.out.println(e.getMessage()); //获取异常简要描述
 5        e.printStackTrace(); //打印异常追踪的堆栈信息
 6    }
 7}
 8class MyException extends Exception{ //自定义异常
 9    public MyException() { //无参
10        super();
11    }
12    public MyException(String message) { //有参
13        super(message);
14    }
15}

集合 ¶

Java.util.*

简介 ¶

1. 数组其实就是一个集合，集合实际上是一个容器，可以容纳其他类型的数据
2. 集合不能直接存储基本数据类型，也不能直接存储Java对象，集合中存储的是Java对象的内存地址（引用，集合在任何时候存储的都是引用）
3. Java中，每个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于放到了不同的数据结构中。数据存储的结构就是数据结构
4. Java中集合分为两类；所有集合继承Iterable（可迭代的），表示所有集合可迭代
   1. 一类是单个方式存储元素（超级父接口：Java.util.Collection；）
      1. List接口：有序的 collection（也称为序列）
         1. ArrayList：采用了数组这种数据结构；初始化容量为10；存储类型为Object类型数组；ArrayList是非线程安全的
         2. Vector：采用了数组这种数据结构；ArrayList是线程安全的；所有方法都有synchronized修饰，但效率较低
         3. LinkedList：采用了双向链表数据结构
         4. 。。。。
      2. Set接口：一个不包含重复元素的 collection，无序指的是存取顺序与取出顺序不一样（没有下标）
         1. HashSet：new HashSet时，底层实际是new了一个HashMap集合；存储数据实际存储在HashMap的key中了（HashMap是一种哈希表数据结构）
         2. SortedSet接口：无序不可重复，该接口实现了元素自动按照大小排序
            1. TreeSet：new TreeSet实际底层new了一个TreeMap集合；往TreeSet中存储数据实际存储在了TreeMap中了（TreeMap底层采用二叉树数据结构）
   2. 一类是以键值对方式存储元素（超级父接口：Java.util.Map；） Map接口：Map集合与Collection集合没有关系；Map集合以key，value这种键值对方式存储元素；key与value存储的都是Java对象的内存地址；Map集合元素key是不可重复的
      1. HashMap：HashMap底层是哈希表数据结构；是非线程安全的
      2. Hashtable：底层也是哈希表数据结构，是线程安全的，现在使用较少
         1. Properties：Properties是线程安全的，因为继承Hashtable；另外Properties存储元素时也采用key与value的形式存储，并且key与value只支持String类型
      3. SortedMap接口：无序不可重复，且实现元素自动排序 1.TreeMap：TreeMap集合底层的数据结构是二叉树

Java.util.Collection ¶

1. 没有使用泛型可以存储Object所有子类型；使用泛型后只能存储某个具体类型（集合中只能存储Java对象的内存地址，不能直接存储基本数据类型和对象）
2. boolean add(E e) ；向集合中添加元素
3. int size()；获取集合中元素的个数
4. void clear() ；清空集合
5. boolean contains(Object o) ；判断集合中是否包含o元素；底层调用equals()方法进行比较，用同样的参数，new出两个字符串对象时，一个加入，一个不加入，会返回true；存放在集合中的类型，一定要重写equals方法。
6. boolean remove(Object o) ；移除集合中某个元素；底层也是调用的equals方法进行对比删除的
7. boolean isEmpty() ；判断集合是否为空；空返回（true）
8. Object[] toArray() ；将集合转换为数组
9. Iterator<E> iterator() ；返回一个Iterator（迭代器） Iterator迭代器中有三个方法：boolean hasNext() 如果仍有元素可以迭代，则返回 true； E next() 返回迭代的下一个元素 ；void remove() 删除迭代器当前指向的元素（会自动更新迭代器中的元素）；集合一旦发生改变，迭代器必须重新获取，否则会出现异常（Java.util.ConcurrentModificationException）；所以在迭代过程中不能改变集合结构
10. 代码示例

 1public static void main(String[] args) {
 2    Collection coll=new ArrayList();
 3    coll.add(123); //自动转换为Inteage，自动装箱
 4    coll.add("tanglei");//向集合中添加元素
 5    coll.add('1'); //添加一样的元素，不会报错，但集合中只有一个
 6    Iterator it=coll.iterator();//获得一个迭代器对象，且集合结构发生变化时必须重新获取
 7    //boolean a=coll.remove('1');//移除集合中某个元素
 8    //coll.clear(); //清空集合元素
 9    System.out.println(coll.isEmpty()); //false
10    System.out.println(coll.contains('1')); //true
11    System.out.println(coll.size()); //输出3
12    while (it.hasNext()){
13        System.out.print(it.next()+" "); //123 tanglei 1
14    }
15}

Java.util.ArryList ¶

1. 有序可重复；List集合有下标，从0开始，依次递增；可重复；非线程安全；默认容量为10；扩容到为原来的1.5倍；
2. 检索效率高，随机增删效率低（因为底层是数组）
3. 对List集合进行排序，放入其中的类型，需要实现Comparable接口
4. void add(int index, E element) ：向指定位置添加元素，效率较低
5. E get(int index) ：根据下标获取元素；List集合可以使用get()方法实现遍历
6. int indexOf(Object o) ：返回此列表第一次出现指定元素的索引
7. int lastIndexOf(Object o) ：返回此列表中最后一次出现指定元素的索引
8. E set(int index, E element) ：修改指定位置的元素
9. >>1二进制右移一位、>>2二进制右移两位；<<1二进制左移一位、«2二进制左移两位

Java.util.LinkedList ¶

1. 底层是一个双向链表；因此具有链表的特性
2. 检索效率较低
3. 随即增删效率较高

Java.util.Vector ¶

1. 底层是一个数组；默认容量10；扩容之后是原容量的2倍

2. 所有方法都是线程同步的，线程安全的。但是效率较低，用的少

3. 将非线程安全转换为线程安全，使用一个工具类可以实现Java.util.Collections

   java

   1 ArrayList coll=new ArrayList();
   2 Collections.synchronizedList(coll); //将ArryList转化为线程安全的，之后coll集合就变成线程安全了

Java.util.Map ¶

1. Map与Collection没有继承关系；Map以key和value方式存储数据；键值对key和value都是引用数据类型；key和value都是存储对象的内存地址；key起主导地位，value是key的一个附属品

2. void clear()；清除所有的映射关系

3. boolean contionsKey(Object key)；是否包含指定键的映射关系

4. boolean contionsValue(Object value)；是否包含指定值的映射关系

5. V get(Object key)；返回指定键映射的值

6. boolean isEmpty()；是否包含有映射关系

7. Set<K> keySet()；返回键的set视图

8. V put(K key,V value)；将指定的值与此映射中指定的键关联，放入一个键值对

9. V remove(Object key)；如果存在一个键的映射，则移除

10. int size()；返回键-值映射关系（键值对）数

11. Collection<V> values()；返回值的Collection视图

12. Set<Map.Entry<K,V>> entrySet()；返回映射关系的set视图

13. Map集合遍历：可以取出Set集合的所有key，然后通过V get(Object key)方法去值；使用foreach方式；

14. 代码示例

    java

     1        Map<Integer,String> map=new HashMap<>();
     2        map.put(1,"王");
     3        map.put(2,"李四");
     4        map.put(3,"王五"); //放入键值对
     5        map.put(1,"张三");
     6        System.out.println(map.size()); //键值对个数
     7        System.out.println(map.get(1)); //获取指定键的值
     8        System.out.println(map.isEmpty()); //映射关系是否为空
     9        Set<Integer> set=map.keySet(); //返回一个key的Set集合
    10        for (Integer data:set){
    11            System.out.print(data+" ");
    12            System.out.print(map.get(data)+"-->");//通过key值遍历map集合
    13        }
    14        System.out.println();
    15        Collection<String> collection=map.values();//返回一个value的Collection集合
    16        for (String data:collection){
    17            System.out.print(data+" ");
    18        }
    19        System.out.println();
    20        Set<Map.Entry<Integer,String>> entrySet = map.entrySet();//返回key=value的Map.ectry<K,V>(Node对象)的数据的Set集合
    21        for (Map.Entry<Integer,String> data:entrySet){
    22            System.out.print(data+" ");
    23        }

Java.util.HashMap ¶

1. HashMap集合底层是哈希表/散列表的数据结构；哈希表是一个数组与单项链表的集合体；哈希表将数组与链表数据结构结合，充分发挥其两者优点；哈希表是一个一维数组（容量达到75%时扩容），数组中每个元素是一个单向链表；HashMap的默认容量必须是2的倍数，为了散列均匀；初始化容量16，默认加载因子0.75

2. hashCode()方法，返回值不能全部一样，也不能全部不一样（变成纯链表或者变成纯数组了）；重写hashCode()方法，需要一定的技巧

3. 放在HashMap集合中key的元素和放在HashSet集合中的元素，都需要重写HashCode()方法以及equals方法

4. 同一个单向链表上，所有结点的hash值相同，因为他们的数组下标相同，但是同一个链表上的k与k的equals肯定返回的是false，都不相等

5. map.put(k,v)；第一步，先将k,v封装到Node对象中；第二步，底层会调用k的hashCode()方法得出hash值，然后通过哈希函数或者哈希算法，将hash值转换成数组的下标，下标位置上如果没有任何元素，就把Node添加到这个位置上，如果说下表对应的位置上有链表，此时会拿着k和链表上每一个节点的k进行equals，如果所有equals都返回false，那么这个新节点将会被添加到链表的末尾。如果其中有一个equals返回了true，那么这个节点的value将会被覆盖

6. map.get(k)；先调用hashCode()方法得出hash值，通过哈希算法转换为数组下标，通过数组下标快速定位到每个位置上，如果这个位置上什么都没有，返回null，如果这个位置上有单向链表，那么会拿着参数k和单向链表上的每个节点中的k进行equals，如果所有的equals方法返回false，那么get()方法返回null，如果其中有一个节点的k和参数k equals返回true，那么此时这个节点的value就是我们要找的value，get方法最终返回这个要找的value

7. JDK8后，如果哈希表单向链表中元素超过8个，则会自动转换为红黑树；在红黑树中节点数量小于6时，又会自动转换为单向链表；原因：提高检索效率

8. 重点：方法HashMap集合中的key元素需要同时重写equals和hashCode方法

9. 代码示例

   java

    1public class HashMapTest {
    2    public static void main(String[] args) {
    3        Student a=new Student("张三");
    4        Student b=new Student("张三");
    5        HashSet<Student> hashSet=new HashSet<>();
    6        hashSet.add(a);
    7        hashSet.add(b);
    8        /*
    9        如果不重写hashCode()方法，这里会输出2；因为底层new了一个HashMap，将元素放入HashMap中key的位置；然而HashMap放元素时，首先执行hashCode方法，
   10        如果不同才会执行equals方法，因此在没有重写时，hashCode会返回false，然后就会在HashMap集合的数组中新建一个Node节点，然后再进行equals方法的对比，
   11        因此，会出现输出为2，放入两个相同的元素；
   12        结论：放入HashMap中元素key位置的，必须同时重写equals与hashCode方法
   13        * */
   14        System.out.println(hashSet.size());
   15    }
   16}
   17class Student{
   18    private String name;
   19    public Student() {
   20    }
   21    public Student(String name) {
   22        this.name = name;
   23    }
   24
   25    @Override
   26    public boolean equals(Object o) { //equals方法重写
   27        if (this == o) return true;
   28        if (!(o instanceof Student)) return false;
   29        Student student = (Student) o;
   30        return Objects.equals(getName(), student.getName());
   31    }
   32    @Override
   33    public int hashCode() { //hashCode方法重写
   34        return Objects.hash(getName());
   35    }
   36
   37    public String getName() {
   38        return name;
   39    }
   40
   41    public void setName(String name) {
   42        this.name = name;
   43    }
   44}

Java.util.Hashtable ¶

1. HashMap的key与value存储时都可以为null，而Hashtable的key与value不能为null，否则会报空指针异常；
2. Hashtable所有方法带有synchronized修饰，线程安全；
3. 扩容时原容量2倍加1；

Java.util.Properties ¶

1. Properties是一个Map集合，继承Hashtable；Properties的key和value都是String类型；Properties被称作属性对象；是线程安全的

2. setProperty()；存储数据进去

3. getProperty()；通过key获取value值

4. 代码示例

   java

   1Properties pro=new Properties();
   2pro.setProperty("12","lei");//存储键值对，且为String类型
   3pro.setProperty("34","tang");
   4System.out.println(pro.size());
   5System.out.println(pro.getProperty("34"));//通过key获取键对应的值

Java.util.TreeSet ¶

1. TreeSet集合底层实际是一个TreeMap
2. TreeMap集合集合底层是一个二叉树
3. 放到TreeSet集合中的元素，等同于放到TreeMap集合的key部分
4. TreeSet集合中元素：无序不可重复，但是可以按照大小顺序自动排序
5. 如果在TreeSet中放入自定义类型，需继承Comparable接口，并实现其中的compareTo()方法，这个方法中写比较规则；返回值=0表相等，返回值>0表左大于右，往右子树上找，<0左边大于右边，往左子树上找；也可以单独写一个比较器，通过构造方法传进去
6. 如果比较规则不会发生改变时，或者说比较规则只有一个，建议实现Comparable接口；如果比较规则有多个，且比较规则之间频繁切换时，建议实现Compartor接口；Comparator接口遵循OOP原则

IO流 ¶

Java.io.*

简介 ¶

1. 通过IO可以完成内存和硬盘之间数据的流动

2. 流方向分类：到内存叫做输入，读；从内存中出来叫做输出，写

3. 流读取方式分类：有的流按照字节读取，一次读取一个字节byte，等同于一次读取8个二进制位，这种流是万能的，什么类型文件都能读取；有的流按照字符方式读取，这种流为了方便读取普通文本文件存在，不能读取：图片，声音，视频等，只能读取纯文本文件

4. Java IO流这块有四大家族；以下是四大家族的首领（抽象类）

   1. Java.io.InputStream：字节输入流
   2. Java.io.OutputStream：字节输出流
   3. Java.io.Reader：字符输入流
   4. Java.io.Writer：字符输出流

   注意：在Java中凡是类名以Stream结尾的都是字节流。以Reader/Writer结尾的都是字符流

5. 所有的流都实现了Java.io.Closeable接口，都是可关闭的，都有close()方法；流毕竟是一个管道，会占用资源，用完后一定要关闭

6. 所有的输出流都实现了Java.io.Flushable接口，都是可刷新的，都有flush()方法；刷新表示将通道或者管道当中剩余的未输出的数据强行输出完(清空管道)

7. Java中需要掌握的io流有16个

   • 文件专属 Java.io.FileInputStream Java.io.FileOutputStream Java.io.FileReader Java.io.FileWriter
   • 转换流（将字节流转化为字符流） Java.io.InputStreamReader Java.io.OutputStreamWriter
   • 缓冲区专属 Java.io.BufferedReader Java.io.BufferedWriter Java.io.BufferedInputStream Java.io.BufferedOutputStream
   • 数据流专属 Java.io.DataInputStream Java.io.DataOutputStream
   • 标准输出流 Java.io.PrintWriter Java.io.PrintStream
   • 对象专属流 Java.io.ObjectInputStream Java.io.ObjectOutputStream

FileInputStream ¶

1. 文件字节输入流，万能，任何文件都可以使用这个流来读；字节方式完成输入操作（硬盘–>内存）；IDEA默认当前路径为工程的根

2. int available()；返回流中剩余没有读到的字节数量

3. long skip(long n)；跳过几个字节不读

4. 代码示例

   java

    1public static void main(String[] args) {
    2        FileInputStream fis=null; //创建字节输入流
    3        int a;
    4        try {
    5            fis=new FileInputStream("module01/src/io/leiking/Javasestud/tempfile"); //当前路径为工程路径
    6            byte[] b=new byte[fis.available()]; //创建一个byte数组，大小为未读文件字节的大小，不适用于大文件，因为byte数组会过大
    7            fis.read(b);
    8            /*
    9            *byte[] bytes=new byte[5];
   10            *int acount=fis.read(bytes);//这里返回值为读取到的字节数量
   11            *也可以设置默认byte数组长度，然后使用String(byte[] bytes, 0, a)方法，转换成字符串
   12             * */
   13/*            还有个skip方法，用于跳过指定字节数不读取
   14            System.out.println(new String(b)); //使用方法，将byte数组转化为字符串
   15            while (((a=fis.read())!=-1)){ //一个字节一个字节的读取，返回值为读取到的字节
   16                System.out.print(a+" ");
   17            }*/
   18        } catch (IOException e) {
   19            e.printStackTrace();
   20        }finally {
   21            if (fis!=null){
   22                try {
   23                    fis.close();
   24                } catch (IOException e) {
   25                    e.printStackTrace();
   26                }
   27            }
   28        }
   29    }

FileOutputStream ¶

1. 文件字节输出流（内存–>硬盘）；写完之后一定要使用flush()刷新

2. 代码示例

   java

    1public static void main(String[] args) {
    2        FileOutputStream fos=null;
    3        try {
    4            //true表示如果文件已经存在，会将数据追加到文件末尾
    5        fos=new FileOutputStream("module01/src/io/leiking/Javasestud/tempfile1",true);
    6            byte[] bytes={97,98,99,32};
    7            fos.write(bytes);//将byte数组写入文件
    8            fos.write(bytes,0,1);//将数组中指定元素写入文件
    9            fos.flush();//FileOutputStream使用后必须刷新
   10        } catch (IOException e) {
   11            e.printStackTrace();
   12        }finally {
   13            if (fos!=null){
   14                try {
   15                    fos.close(); //关闭流
   16                } catch (IOException e) {
   17                    e.printStackTrace();
   18                }
   19            }
   20        }
   21    }

   其他代码 ¶

   文件复制

   java

    1    public static void main(String[] args) {
    2        FileInputStream fis=null;
    3        FileOutputStream fos=null;
    4        try {
    5            fis=new FileInputStream("F:\\源码\\EditPlus5.3.0.2542\\EditPlus_5.3.0.2542_x64_SC.exe");//输入流
    6            fos=new FileOutputStream("Test");
    7            byte[] bytes=new byte[1024*1024];//一次性读取1M大小
    8            while (fis.read(bytes)!=-1){//当读取的字节数为-1时，结束循环，且将读取的字节存入bytes数组
    9                fos.write(bytes);//向文件中写入bytes中内容
   10            }
   11        } catch (IOException e) {
   12            e.printStackTrace();
   13        } finally{
   14            if(fis!=null){
   15                fis.close();//关闭输入流
   16            }
   17            if(fos!=null){
   18                fos.close();//关闭输出流
   19            }
   20        }
   21    }

Reader和Writer ¶

1. 文件字符输入流，读取文本时比较方便

2. 按照字符方式读取，一次读取一个字符

3. 代码示例

   java

    1public static void main(String[] args) {
    2        Reader reader=null;
    3        Writer writer=null;
    4        try {
    5            reader=new FileReader("module01/1.html"); //字符输入流
    6            writer=new FileWriter("2",true); //字符输出流
    7            char[] a=new char[10];
    8            int count; //记录读取文本文档字符的个数
    9            while ((count=reader.read(a))!=-1){
   10                writer.write(a,0,count);//将数组中的元素写入文件
   11            };
   12            writer.flush(); //刷新输出流（必要步骤）
   13        } catch (IOException e) {
   14            e.printStackTrace();
   15        }finally {
   16            if (reader!=null){
   17                try {
   18                    reader.close(); //关闭流
   19                } catch (IOException e) {
   20                    e.printStackTrace();
   21                }
   22            }
   23            if (writer!=null){
   24                try {
   25                    writer.close(); //关闭流
   26                } catch (IOException e) {
   27                    e.printStackTrace();
   28                }
   29            }
   30        }
   31    }

缓冲流 ¶

1. 带有缓冲区的流，不需要定义char数组或者byte数组；BufferedReader、BufferedWriter

2. 当一个流的构造方法中需要传入一个流时，这个被传入的流叫做：节点流；外面的流叫做：处理流；且关闭流时只需要调用最外层流（处理流）的close()方法

3. 转换流，可以进行流之间的转换；InputStreamReader\OutputStreamWriter

4. 代码示例

   java

    1    public static void main(String[] args) throws Exception {
    2        FileInputStream fis=new FileInputStream("2");//字节流
    3        InputStreamReader isr=new InputStreamReader(fis);//字节流转换为字符流
    4        BufferedReader br=new BufferedReader(isr);
    5        String data;
    6        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("3")));
    7        while ((data=br.readLine())!=null){//读取一行，但是读取不到换行符,没数据时返回null
    8            bw.write(data);//将字符串输出到文件
    9            bw.write("\n");
   10        }
   11        bw.flush();//刷新缓冲区输出流
   12        br.close();//关闭最外层流
   13        bw.close();//关闭最外层流
   14    }

数据流 ¶

1. 这个流可以将数据连同数据的类型一并写入文件；这个文件不是普通文本文件，不能用记事本打开

2. 读取数据类型的顺序一致，否则会出现问题；类似于加密规则

3. 代码示例

   java

    1    public static void main(String[] args) throws Exception{
    2        DataOutputStream dos=new DataOutputStream(new FileOutputStream("4"));
    3        int a=100;
    4        char b='a';
    5        dos.writeInt(a);
    6        dos.writeChar(b);
    7        dos.flush();
    8        dos.close();
    9        DataInputStream dis=new DataInputStream(new FileInputStream("4"));
   10        System.out.println(dis.readInt());//读取数据时，类型与存储时一致
   11        System.out.println(dis.readChar());
   12        dis.close();
   13    }

标准输出流 ¶

1. 标准字节输出流，默认输出到控制台；标准输出流不需要手动关闭流

2. 可以改变标准输出流的方向

3. 代码示例

   java

    1    public static void log(String msg){
    2        try {
    3            //改变标准输出流方向到log文件
    4            PrintStream ps=new PrintStream(new FileOutputStream("log",true));
    5            Date date=new Date();
    6            //时间格式化对象
    7            SimpleDateFormat a=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
    8            ps.println(a.format(date)+"-->"+msg);//输出内容到log文件
    9        } catch (FileNotFoundException e) {
   10            e.printStackTrace();
   11        }
   12    }
   13    public static void main(String[] args) {
   14        log("用户登录了");
   15        log("登陆失败了");
   16    }

Java.io.File ¶

1. File类与四大家族没有关系，所以File类不能完成文件的读和写

2. File对象代表的是文件和目录路径名的抽象表示形式；一个File对象可能是目录，也有可能是文件

3. boolean createNewFile() ；不存在时，新建一个文件

4. boolean delete() ；删除此抽象路径名表示的文件或目录

5. boolean mkdir()；创建此抽象路径名指定的目录

6. String getParent() ； 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null

7. String getPath() ；将此抽象路径名转换为一个路径名字符串

8. boolean exists() ； 测试此抽象路径名表示的文件或目录是否存在

9. boolean isDirectory() ； 测试此抽象路径名表示的文件是否是一个目录

10. boolean isFile() ；测试此抽象路径名表示的文件是否是一个标准文件

11. long lastModified() ；返回此抽象路径名表示的文件最后一次被修改的时间，返回的是一个毫秒，1970年到现在的总毫秒数

12. long length()； 返回由此抽象路径名表示的文件的长度，获取文件大小

13. File[] listFiles() ；返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件

14. 代码示例（重点理解，目录的复制）

    java

     1    public static void main(String[] args) {
     2        File soufile=new File("F:\\源码\\Java");
     3        File desfile=new File("D:\\a");
     4        copy(soufile,desfile);
     5    }
     6
     7    /**
     8     *复制文件夹的方法
     9     * @param soufile 源文件夹
    10     * @param desfile 目标文件位置
    11     */
    12    public static void copy(File soufile,File desfile){
    13        if (soufile.isFile()){//如果是一个文件就返回，递归终止条件
    14            FileInputStream fis=null;
    15            FileOutputStream fos=null;
    16            try {
    17                byte[] bytes=new byte[1024*1024];
    18                fis=new FileInputStream(soufile);
    19                int count=0;
    20                String path=(desfile.getAbsolutePath().endsWith("\\")?desfile.getAbsolutePath():desfile.getAbsolutePath()+"\\")+soufile.getAbsolutePath().substring(6);
    21                System.out.println(path);
    22                fos=new FileOutputStream(path);
    23                while ((count=fis.read(bytes))!=-1){
    24                    fos.write(bytes,0,count);
    25                }
    26                fos.flush();//刷新流
    27            } catch (IOException e) {
    28                e.printStackTrace();
    29            }finally {
    30                if (fis!=null){
    31                    try {
    32                        fis.close();
    33                    } catch (IOException e) {
    34                        e.printStackTrace();
    35                    }
    36                }
    37            }
    38            return;
    39        }
    40        File[] files=soufile.listFiles();
    41        for (File a:files){
    42            File newFile=null;
    43            if (a.isDirectory()){ //是否为目录
    44                String srcDir=a.getAbsolutePath();//抽象路径名的绝对路径名形式
    45                String desDir=(desfile.getAbsolutePath().endsWith("\\")?desfile.getAbsolutePath():desfile.getAbsolutePath()+"\\")+srcDir.substring(6);//返回绝对路径
    46                newFile=new File(desDir);//创建File对象
    47                if (!newFile.exists()){ //文件夹不存在
    48                    newFile.mkdirs();//创建文件夹,包括所有必需但不存在的父目录
    49                }
    50            }
    51            copy(a,desfile);
    52        }
    53    }

对象流 ¶

1. 序列化：将对象存储到硬盘中（拆分对象）；反序列化：将对象从硬盘中取出（组装对象）

2. 参与序列化和反序列化的对象必须实现Serializable接口，这个接口中什么代码都没有，仅作为标识；标志接口，给JVM看的，JVM看到后会自动生成一个序列化版本号

3. Java中区分类：首先靠类名进行区分，如果一样，则靠序列化版本号区分；

4. 序列化版本号的缺陷，一旦代码确定后，后面不能修改代码，一旦修改，会重新编译，生成新的序列化版本号，JVM会认为这是一个新的类；因此，建议实现Serializable接口的，手动给予序列化版本号

5. 可以将对象放入集合，实现一次性序列化多个对象

6. 属性定义可以使用transient关键字修饰，表示游离的，该字段不参与序列化

7. 代码示例

   java

    1    public static void main(String[] args) throws Exception{
    2        Student a=new Student("李云",25);
    3        Student b=new Student("王炸",32);
    4        ArrayList<Student> al=new ArrayList<>();
    5        al.add(a);
    6        al.add(b);
    7        ObjectOutputStream oop=new ObjectOutputStream(new FileOutputStream("students"));
    8        oop.writeObject(al); //序列化ArryList集合
    9        oop.flush();
   10        oop.close();
   11        ObjectInputStream oip=new ObjectInputStream(new FileInputStream("students"));
   12        Object als=oip.readObject(); //反序列化
   13        ArrayList<Student> als1=(ArrayList)als;
   14        for (Student data:als1){
   15            System.out.println(data);
   16        }
   17    }
   18class Student implements Serializable {
   19    private static final long serialVersionUID = 1L;//手动给序列化版本号
   20    private String name;
   21    private int age;
   22
   23    public Student(String name, int age) {
   24        this.name = name;
   25        this.age = age;
   26    }
   27
   28    @Override
   29    public String toString() {
   30        return "Student{" +
   31                "name='" + name + '\'' +
   32                ", age=" + age +
   33                '}';
   34    }
   35}

其他 ¶

1. IO+Properties联合使用（读取配置文件）
2. 类似于key=value，被称为属性配置文件，Java中建议使用.properties结尾；属性配置文件中使用**#**进行注释
3. 代码示例

1public static void main(String[] args) throws Exception{
2    FileReader fr=new FileReader("config.properties");//字符输入流
3    Properties prope=new Properties();//创建一个属性集合
4    prope.load(fr);//从输入流中读取数据
5    System.out.println(prope.getProperty("username"));//获取username属性的值
6    System.out.println(prope.getProperty("password"));//获取password属性的值
7}

多线程 ¶

简介 ¶

1. 进程是一个应用程序（一个进程是一个软件）；线程是一个进程的执行场景/执行单元；一个进程可以有多个线程
2. 对于Java程序来说，当在DOS命令窗口中输入：Java HellowWorld回车之后；会首先启动JVM，而JVM就是一个进程；JVM再启动一个主线程调用main方法；同时再启动一个垃圾回收线程负责看护，回收垃圾；Java程序中至少有两个线程并发
3. Java中进程内存互不干扰；线程的堆内存和方法区内存共享；栈内存独立，一个线程一个栈；多线程机制目的是提高程序执行效率
4. main方法（主线程）结束，程序不一定执行完毕，可以有其他线程还在压栈弹栈

实现线程两种方式 ¶

1. 第一种：编写一个类直接继承Java.lang.Thread，重写run方法；然后new就可以创建线程；使用strat()方法开辟新的栈空间，瞬间执行结束，线程就启动成功；启动成功后自动调用run方法，且压栈到新栈的底部（与main类似）

2. 第二种：编写一个类实现Java.lang.Runnable接口；这个类并不是一个线程类，是一个可运行的类；先创建一个可运行的对象，然后将可运行的对象封装成一个线程对象；同样使用start()启动线程（开辟栈空间）

3. 建议使用第二种方式，实现接口；因为这样以后还能继承其他类，比较灵活

4. 代码示例

   java

    1public class ThreadTest01 {
    2    public static void main(String[] args) {
    3        Student stu=new Student();
    4        stu.start(); //开辟栈空间（很快执行结束），会自动调用run()方法，并压栈到新栈底部
    5        for (int i=0;i<1000;i++){
    6            System.out.println("main线程--->"+i);
    7        }
    8    }
    9}
   10class Student extends Thread{
   11    @Override
   12    public void run() {
   13        for (int i=0;i<1000;i++){
   14            System.out.println("分支线程--->"+i);
   15        }
   16    }
   17}

   java

    1public class ThreadTest02 {
    2    public static void main(String[] args) {
    3        Stud stud = new Stud();//创建可运行对象
    4        Thread thread = new Thread(stud);//封装成线程对象
    5        thread.start();//开辟栈空间
    6        for (int i = 0; i < 1000; i++) {
    7            System.out.println("main线程-->" + i);
    8        }
    9    }
   10}
   11
   12class Stud implements Runnable {
   13    @Override
   14    public void run() {
   15        for (int i = 0; i < 1000; i++) {
   16            System.out.println("分支线程-->" + i);
   17        }
   18    }
   19}

线程生命周期 ¶

1. 才new出来的线程叫做新建状态；通过start(),线程变成就绪状态；run()方法执行标志进入运行状态，时间片用完会继续进入就绪状态抢夺时间片，直到线程执行完，当线程遇到阻塞事件，会进入阻塞状态，此时会放弃抢夺的时间片；当阻塞清除时，会自动回到就绪状态抢夺时间片；就绪状态和运行状态切换，是JVM调度
2. 新建状态：刚new出一个线程时
3. 就绪状态：此时线程具有抢夺CPU时间片的权利，抢夺成功进入就绪状态
4. 运行状态：线程运行，时间片用完会进入就绪状态继续抢夺时间片，直到线程结束，遇到阻塞事件，会进入阻塞状态
5. 阻塞状态：此时线程放弃之前抢夺的时间片，清除阻塞时会进入就绪状态，抢夺时间片
6. 死亡状态：

获取线程对象 ¶

1. 获取当前线程对象：static Thread.currentThread()；出现在哪个线程对象中，就是获取哪个线程对象

2. 获取线程对象名字：getName()方法

3. 修改线程对象名字：setName()方法

   java

    1public class ThreadTest03 {
    2    public static void main(String[] args) {
    3        Thread thread=new Thread(new Stud03());
    4        thread.start();//启动线程（开辟新栈）
    5    }
    6}
    7class Stud03 implements Runnable{
    8    @Override
    9    public void run() {
   10        Thread a=Thread.currentThread();//获取当前线程对象
   11        System.out.println(a.getName());//获取当前线程对象名字
   12        a.setName("th1");//修改当前线程对象名字
   13        System.out.println(a.getName());
   14    }
   15}

线程状态改变 ¶

1. static void sleep(Long millis)；是一个静态方法；参数是毫秒；作用：让线程进入休眠，运行在哪个线程中，则让哪个线程休眠

2. t.interrupt()方法，中断t线程休眠（这种中断睡眠的方式依靠了Java的异常处理机制）

3. t.stop()强行终止线程（已过时），缺点：容易丢失数据；给一个标记，修改标记达到终止线程的目的

4. 代码示例

   java

    1public class ThreadTest04 {
    2    public static void main(String[] args) {
    3        Mythread1 r = new Mythread1();//可运行程序
    4        Thread th = new Thread(r);
    5        th.start();//启动线程
    6        th.setName("t");//设置名字
    7        try {
    8            Thread.sleep(1000);//休眠1s
    9        } catch (InterruptedException e) {
   10            e.printStackTrace();
   11        }
   12        th.interrupt();//终止th线程休眠
   13        r.setRun(false); //采用标志终止线程
   14        //th.stop();//终止线程，过时，不建议使用
   15        System.out.println("main线程");
   16    }
   17}
   18
   19class Mythread1 implements Runnable {
   20    private boolean run = true;//线程运行标志
   21    @Override
   22    public void run() {
   23        for (int i = 0; i < 100; i++) {
   24            if (run) {
   25                System.out.println(Thread.currentThread().getName() + "-->" + i);
   26                try {//这里只能使用try catah，因为实现方法，不能抛出更多异常
   27                    Thread.sleep(3000);//休眠3秒
   28                } catch (InterruptedException e) {
   29                    e.printStackTrace();
   30                }
   31            } else {
   32                System.out.println("线程终止");
   33                return;
   34            }
   35        }
   36    }

线程调度 ¶

1. 调度模型

   1. 抢占式调度模型（Java）：哪个线程优先级高，抢到时间片的概率就高一些
   2. 均分式调度模型：平均分配时间片，每个线程占有时间片的时间长度一样

2. Java中与线程调度有关的方法

   1. void setPriority(int newPriority)：更改线程的优先级 ； int getPriority() ：返回线程的优先级 最低优先级1；默认优先级5；最高优先级10；优先级高的可能获取时间片机会高一些

   2. static void yield() ：暂停当前正在执行的线程对象，并执行其他线程 ；不是阻塞方法，yield方法会让当前线程转换为就绪状态

   3. void join()：合并线程；t.jion()：当前线程进行阻塞，执行t线程，直到t线程执行结束，当前线程继续执行，相当于将t线程合并到当前线程

   4. 代码示例

      java

       1public class ThreadTest05 {
       2    public static void main(String[] args) {
       3        Thread th=new Thread(new MyThread05());
       4        th.setPriority(10);//设置优先级10
       5        System.out.println(Thread.currentThread().getPriority());//获取当前线程优先级
       6        th.start();
       7        try {
       8            th.join(); //将th线程加入当前线程，并阻塞当前线程
       9        } catch (InterruptedException e) {
      10            e.printStackTrace();
      11        }
      12        for (int i=0;i<100;i++){
      13            System.out.println(Thread.currentThread().getName()+"-->"+i);
      14        }
      15    }
      16}
      17class MyThread05 implements Runnable{
      18    @Override
      19    public void run() {
      20        System.out.println(Thread.currentThread().getPriority());//获取当前线程优先级
      21        for (int i=0;i<100;i++){
      22            if (i%9==0){
      23                Thread.yield();//暂停当前执行，转换为就绪状态抢夺时间片
      24            }
      25            System.out.println(Thread.currentThread().getName()+"-->"+i);
      26        }
      27    }
      28}

线程同步 ¶

1. 注意：自己写的程序会放到多线程的环境下运行，需要关注自己写的代码在多线程环境下数据的安全问题

2. 线程安全问题

   1. 多线程并发
   2. 有共享数据
   3. 共享数据有修改行为

3. 解决线程安全问题 线程排队执行（不能并发）机制；这种机制被称为线程同步机制；只有数据安全后才可以谈执行效率

4. 编程模型

   1. 异步编程模型：t1和t2各自互不干扰的执行，线程并发，效率高
   2. 同步编程模型：t1和t2排队执行，线程同步，效率较低

5. 同步代码块synchronized ()（排他锁）；小括号中传的数据必须是多线程共享的”数据“，才能达到多线程排队；小括号中写的内容根据需求：你需要哪些线程同步;Java中任何对象都有一把锁（标志）；字符串（常量池中）是一个万能锁

   java

    1    public void quQian(Double qu){//取钱方法
    2        synchronized (this){ //t1 t2共享对象，对象锁，同步代码块 线程同步
    3            Double after=this.money-qu;//取钱后余额
    4            try {
    5                Thread.sleep(1000);//休眠1s，必定会出现安全问题
    6            } catch (InterruptedException e) {
    7                e.printStackTrace();
    8            }
    9            setMoney(after);//更新余额
   10        }

   上面代码t1和t2线程并发执行，假设t1执行时，遇到synchronized，会自动找后面”共享对象“的对象锁，找到后并占有，直到执行完才释放；此时t2线程如果遇到synchronized时，也会去占有后面”共享对象“的这把锁，发现已经被t1占有时，只能在代码块外等待t1执行完归还锁后，才能继续占有这把锁，然后执行同步代码块（就绪状态抢夺时间片）

6. synchronized ()出现在实例方法上，锁的一定是this；缺点：代表整个方法体需要同步，可能扩大同步范围，效率低；优点：代码简洁

   java

   1public synchronized void getChar(){}

7. 局部变量永远都不会存在安全问题（不共享，栈中，一个线程一个栈）；实例变量在堆中（堆只有一个），可能存在线程安全问题；静态变量存在方法区中（方法区只有一个），存在线程安全问题

8. 如果使用局部变量，建议使用StringBuilder（非线程安全），StringBuffer（线程安全）效率较低；ArrayList（不安全），Vector（安全）；HashMap（不安全），Hashtable（安全）

9. synchroized()三种写法

   1. 同步代码块
   2. 实例方法上使用synchroized
   3. 静态方法上使用synchroized，代表类锁，类锁永远只有一把

10. 死锁：不出异常，也不会出现错误

    java

     1    public void run() {
     2        if (Thread.currentThread().getName().equals("t1")){
     3            synchronized (m1){ 
     4                try {
     5                    Thread.sleep(1000);
     6                } catch (InterruptedException e) {
     7                    e.printStackTrace();
     8                }
     9                synchronized (m2){//锁m2时，等待t2执行完毕；构成死锁
    10                    System.out.println("t1");
    11                }
    12            }
    13        }
    14        if (Thread.currentThread().getName().equals("t2")){
    15            synchronized (m2){
    16                try {
    17                    Thread.sleep(1000);
    18                } catch (InterruptedException e) {
    19                    e.printStackTrace();
    20                }
    21                synchronized (m1){//锁m1时，等待t1执行完毕；构成死锁
    22                    System.out.println("t2");
    23                }
    24            }
    25        }
    26    }

11. 开发中解决线程安全问题

    1. 尽量使用局部变量代替“实例变量和静态变量”
    2. 如果必须是实例变量，那么可以创建多个对象
    3. 如果上面两条都不可以使用，那么才选择synchroized同步代码块。线程同步机制

守护线程 ¶

1. 线程分类

   1. 用户线程
   2. 守护线程（后台线程），垃圾回收机制

2. 守护线程特点：一般守护线程是一个死循环，所有的用户线程结束，守护线程自动结束

3. 在线程启动之前设置为守护线程：t.setDaemon(true)；将t线程设置为守护线程

4. 代码示例

   java

    1public class ThradTest07 {
    2    public static void main(String[] args) {
    3        Thread t = new MyThrad07();
    4        t.setDaemon(true);//设置为守护线程
    5        t.start();
    6        for (int i=0;i<10;i++){
    7            try {
    8                Thread.sleep(1000);
    9            } catch (InterruptedException e) {
   10                e.printStackTrace();
   11            }
   12            System.out.println(Thread.currentThread().getName()+"-->"+i);
   13        }
   14    }
   15}
   16
   17class MyThrad07 extends Thread {
   18    @Override
   19    public void run() {
   20        int i = 0;
   21        while (true) {
   22            try {
   23                Thread.sleep(1000);
   24            } catch (InterruptedException e) {
   25                e.printStackTrace();
   26            }
   27            System.out.println(Thread.currentThread().getName() + "-->" + i++);
   28        }
   29    }
   30}