Java基础3

System类：
方法：System.currentTimeMillis()：获取当前时刻的时间
public static void arraycopy(Obiect src,int srePos,Object dest,int destPos,int length):将数组中指定的数据拷贝到另一个数组中。

long s = System.currentTimeMillis();//可以用来测试程序效率

StringBuilder类：字符串缓冲区，可以提高字符串的效率

package StringBuilderDemo;

/**
 * 1.构造方法
 * (1)StringBuilder();
 * (2)StringBuilder(String str);    String->StringBuilder
 * 2.常用方法
 * (1)public StringBuilder append():添加任意类型数据的字符串形式，并返回当前对象自身
 * (2)public String toString():将当前StringBuilder对象转换为String对象   StringBuilder->String
 */

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1);
        StringBuilder sb2 = new StringBuilder("hello world");
        System.out.println(sb2);

        sb2.append(" Java");
        System.out.println(sb2);

        //System.out.println(sb2.length());

        String s = sb2.toString();
        
        //s.append("sbc");
        System.out.println("s:"+s);
    }
}

@[基本类型与字符串之间的转换：]

package StringBuilderDemo;

/**
 * 基本类型与字符串之间的相互转换
 * 基本类型->字符串
 * 1.基本类型的值+" ";（最简单的方法，工作中常用）
 * 2.包装类的静态方法，toString(参数)，不是Object类的toString重载
 * static String toString(int i) 返回一个表示指定整数的String对象
 * 3.String类的静态方法valueOf(参数)
 * static String valueOf(int i)   返回int参数的字符串表示形式
 *
 * 字符串->基本类型
 * 使用包装类的静态方法parseXXX("数值类型的字符串")；
 */

public class baseToString {
    public static void main(String[] args) {
        int i1 = 100;
        String s1 = i1 + "";
        System.out.println(s1+200);//100200

        String s = Integer.toString(100);
        System.out.println(s+200);//100200

        String s2 = String.valueOf(100);
        System.out.println(s2+200);//100200

        int i = Integer.parseInt(s1);
        System.out.println(i-10);//90
    }
}

Collection集合：

package CollectionDemo;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.Collection;

/**
 * 所有单列集合的最顶层接口，里边定义了所有单列集合共性的方法
 * 共性方法：
 * 1.public boolean add(E e):把给定的对象添加到当前集合中
 * 2.public void clear():清空集合中的所有元素
 * 3.public boolean remove(E e):把给定的对象在当前集合中删除
 * 4.public boolean contains(E e):判断当前集合中是否包含给定的对象
 * 5.public boolean isEmpty():判断当前集合是否为空
 * 6.public int size():返回集合中元素的个数
 * 7.public Object[] toArray():把集合中的元素，存储到数组中
 *
 *
 */

public class CollectionDemo01 {

    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);

        coll.remove("王五");
        System.out.println(coll);

        boolean flag = coll.contains("王五");
        System.out.println(flag);

        boolean flag1 = coll.isEmpty();
        System.out.println(flag1);

        Object[] objects = coll.toArray();
        for (Object object : objects) {
            System.out.println(object);
        }

        coll.clear();
        System.out.println(coll.isEmpty());


    }
}

Iterator迭代器：

package CollectionDemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * Iterator:迭代器（对集合进行遍历）
 *
 * 有两个常用的方法：
 * boolean hasNext()  如果仍有元素可以迭代，则返回true
 * 判断集合中还有没有下一个元素，有就返回true，没有就返回false
 *
 * E next() 返回迭代器的下一个元素
 * 取出集合中的下一个元素
 * Iterator迭代器是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊，Collector
 * 接口中有一个方法，叫iterator（），这个方法返回的就是迭代器的实现类对象
 *
 * Iterator<E> iterator() 返回在此collection的元素上进行迭代的迭代器
 *
 * 迭代器使用步骤：
 * 1.使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
 * 2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
 * 3.使用Iterator接口中的方法next()取出集合中的下一个元素
 */

public class IteratorDemo {

    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();

        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");

        Iterator<String> it = coll.iterator();
        while(it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }
    }
}

含有泛型的类/接口和方法：

package CollectionDemo;

/**
 * 定义一个泛型，模拟ArrayList集合
 * 泛型是一个位置的数据类型，当我们不确定什么数据类型的时候，可以使用泛型
 * 泛型可以接收任意的数据类型，可以使用Interger，String。
 * 创建对象的时候可以确定泛型的数据类型
 * 
 * 
 * 含有泛型的方法：
 * public <T> void method(T var){
 *     
 * }
 */

public class GenericDemo<E> {
    private E name;
    
    public E getName(){
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

泛型的优缺点：

LinkedList:

package CollectionDemo;

/**
 * LinkedList集合特点：
 * 1.底层是链表，查询慢，增删快
 * 2.里边有大量操作首尾元素的方法
 * 注意：使用LinkedList集合特有的方法，不能使用多台
 * 
 * public void addFirst(E e):将指定元素插入此列表的开头
 * public void addLast(E e):将指定元素插入此类表的末尾
 * public E getFirst(E e):返回此列表的第一个元素
 * public E getLast (E e):返回此列表的最后一个元素
 * public E removeFirst():移除并返回此列表的第一个元素
 * public E removeLast():移除并返回此列表的最后一个元素
 * public E pop():从此列表所表示的堆栈处弹出一个元素，等价于在开头删除元素
 * public void push(E e):将元素推入此列表所表示的堆栈,等价于在开头插入元素
 * public boolean isEmpty():如果列表不包含元素，则返回true
 * 
 */

public class listDemo {

    public static void main(String[] args) {
        
    }
}

HashSet集合：
注意：HashSet集合存储自定义元素，需要重写hashCode()和equal（）方法

package CollectionDemo;

import java.util.HashSet;
import java.util.Iterator;

/**
 * HashSet特点：
 * 1.不允许存储重复元素
 * 2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
 * 3.是一个无序的集合，存储元素和取出元素的顺序有可能不一致
 * 4.底层是一个哈希表结构，查询的速度快
 */

public class hashSet {
    public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);

        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer next = it.next();
            System.out.println(next);
        }

        for (Integer integer : set) {
            System.out.println(integer);
        }
    }
}

可变参数：
参数的类型确定，参数的个数不确定

注意事项：
1.一个方法的的参数列表，只能有一个可变参数
2.如果方法的参数有多个，那么可变参数必须写在参数列表的末尾

package CollectionDemo;

public class changeVar {
    public static void main(String[] args) {
        int result = add(10,20,30,40,50);
        System.out.println(result);
    }

    public static int add(int...arr){
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        return sum;
    }
}

Collections集合类工具：

package CollectionDemo;

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

/**
 * public static <T> boolean addAll(Collection<T> c,T... elements):往集合中添加一些元素
 * public static void shuffle(List<?> list):打乱集合顺序
 * public static <T> void sort(list<T> list):将集合中的元素按照默认规则排序
 * public static <T> void sort(list<T> list,Comparator<? super T>):将集合中元素按照指定规则排序
 */

public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","e");
        System.out.println(list);

        Collections.shuffle(list);
        System.out.println(list);

        System.out.println("======================================");
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(3);
        list01.add(2);
        list01.add(1);

        Collections.sort(list01);
        System.out.println(list01);

        System.out.println("======================================");
        ArrayList<Integer> list02 = new ArrayList<>();
        list02.add(3);
        list02.add(2);
        list02.add(1);

        Collections.sort(list02, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(list02);

        ArrayList<Person> list1 = new ArrayList<>();
        list1.add(new Person("迪丽热巴",18));
        list1.add(new Person("古力娜扎",20));
        list1.add(new Person("杨幂",17));

        Collections.sort(list1, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println(list1);



    }
}

Map集合：
Map是双列集合，Collection是单列集合。
Map接口中的常用方法：
map.entry对象：

package Map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Map集合的特点：
 * 1.Map集合是一个双列集合，一个元素包含两个值
 * 2.Map集合中的元素，key和value的数据类型可以相同，也可以不同
 * 3.Map集合中的元素，key是不允许重复的，value是可以重复的（与函数定义类似）
 * 4.Map集合中的元素，key和value是一一对应的
 * 主要实现有HashMap与LinkedHashMap
 *
 *
 * Map中定义的方法：
 * public V put (K key,V value):把指定的键与指定的值添加到Map集合中
 * public V remove (Object key):把指定的键从所对应的的键值对元素在Map集合中删除，返回被删除元素的值
 * public V get(Object key):根据指定的键，在Map集合中获取对应的值
 * boolean containsKey(Object key):判断集合中是否包含指定的键
 * public Set<K> keySet():获取Map集合中所有的键，存储到Set集合中
 * public Set<Map.Entry<K,V>> entrySet():获取到Map集合中所有的键值对对象的集合（Set集合）
 */

public class MaoDemo1 {

    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        map.put("李晨","范冰冰");
        map.put("冷锋","龙小云");
        map.put("杨过","小龙女");
        map.put("尹志平","小龙女");

        System.out.println(map);


        Map<String,Integer> map1 = new HashMap<>();
        map1.put("赵丽颖",168);
        map1.put("杨颖",165);
        map1.put("林志玲",178);

        System.out.println(map1);
        Integer v1 = map1.remove("林志玲");
        System.out.println(v1);

        boolean flag = map1.containsKey("赵丽颖");
        System.out.println(flag);

        Set<String> str1 = map1.keySet();
        for (String s : str1) {
            Integer s1 = map1.get(s);
            System.out.println("key:"+s+"  value:"+s1);
        }

        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String str3 = entry.getKey();
            String str4 = entry.getValue();
            System.out.println(str3+"="+str4);
        }

    }
}

Debug程序：
F8：逐行执行程序
F7：进入到方法中
F9：跳入到下一个断点

异常：

Exception异常处理方式：
1.抛出异常，交给JVM处理，虚拟机会中断处理，程序被强制退出，后面代码不再执行。
2.try catch处理，异常处理后，后面代码还可以继续执行。
异常分类：

package Exception;

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

/**
 * Throwable:类是Java中所有错误或异常的超类
 * Exception:编译器异常，记性编译java程序出现的问题
 * RuntimeException:运行期异常，java程序运行过程中出现的问题
 * 异常就相当于程序得了一个小毛病，把异常处理掉，程序就可以继续执行
 *
 * Error:错误
 * 错误就相当于程序得了一个无法治愈的毛病，必须修改源代码，程序才能执行
 */

public class ExceptionDemo {
    public static void main(String[] args) {
        //Exception:编译器异常，记性编译java程序出现的问题
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//用来格式化日期
        try {
            Date date = sdf.parse("1999-09-09");//把字符串格式的日期，解析为Date格式的日期
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
        //RuntimeException:运行期异常，java程序运行过程中出现的问题
        int[] nums = {1,2,3};
        try{
            //可能出现异常的代码
            System.out.println(nums[3]);
        }catch (Exception e){
            //异常的处理逻辑
            System.out.println(e);
        }
        
        //Error:错误
        // * 错误就相当于程序得了一个无法治愈的毛病，必须修改源代码，程序才能执行
        int[] arr = new int[1024*1024*1024];
        //必须修改代码，创建的数组小一点
    }
}

异常处理的关键字：try catch throw throws finally
throw关键字：

package Exception;

/**
 * throw关键字：
 * 作用：
 * 可以使用throw关键字在指定的方法中抛出指定的异常
 * 使用格式：
 * throw new xxxException("产生异常的原因")；
 * 注意：
 * 1.throw关键字必须写在方法的内部
 * 2.throw关键字后边new的对象必须是Exception或者是Exception的子类对象
 * 3.throw关键字抛出的异常，我们必须处理这个异常
 * Throw关键字后边创建的是RunTimeException或者是RunTimeException的子类，我们可以不处理，默认交给JVM处理
 * （打印异常对象，中断程序）
 * Throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throws,要么try...catch
 */

public class ExceptionDemo2 {
    public static void main(String[] args) {
        int[] arr = null;
        int e = getElement(arr,0);
        System.out.println(e);
    }
    /**
     * 定义一个方法，获取数组指定索引处的元素
     * 参数：int[]  arr,   int index
     * 以后工作中，我们必须对方法传递过来的参数进行合法性校验，如果参数不合法，那么我们就必须使用抛出异常的方式，
     * 告知方法的调用者，传递的参数有问题
     */
    
    
    public static  int getElement(int[] arr,int index){
        /**
         * 我们可以对传递过来的参数数组，进行合法性校验
         * 如果数组arr的值是null，那么我们就抛出空指针异常，告知方法的调用者“传递的数组的值是null”
         * 注意：NullPointerException是一个运行时异常，我们不用处理，默认交给JVM处理
         */
        
        if(arr == null){
            throw new NullPointerException("传递的数组的值是null");
        }

        /**
         * 我们可以对传递过来的参数index进行合法性校验
         * 如果index的范围不在数组的索引范围内，那么我们就抛出数组越界异常，
         * 告知方法的调用者“传递的索引超出了数组的使用方位”
         */
        if(index<0 || index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用方位");
        }
    }

}

处理异常的第一种方式：throws

package Exception;

import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * throw关键字：异常处理的第一种方式，交给别人处理
 * 作用：当方法内部抛出异常对象的时候，我们就必须处理这个异常
 * 可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理，最终交给JVM处理
 * 使用格式：
 * 修饰符 返回值类型 方法名（参数列表） throws  AAAException,BBBException...{
 *     throw new AAAException("产生原因");
 *     throw new BBBException("产生原因");
 *     ......
 *
 * }
 * 注意：
 * 1.throws关键字必须写在方法声明处
 * 2.throws关键字后边声明的异常必须是Exception或者是Exception的子类
 * 3.如果方法内部抛出了多个异常，那么throws后边也必须声明多个异常，
 * 如果抛出的异常有子父类关系，那么直接声明父类异常即可
 * 4.调用一个声明抛出异常的方法，我们就必须处理声明的异常。
 * 要么继续使用throws声明抛出异常，交给方法的调用者处理，最终交给JVM；要么try...catch自己处理异常
 *
 */

public class ExceptionDemo3 {
    public static void main(String[] args) throws FileNotFoundException,IOException {
        readFile("c:\\a.txt");
    }

    /**
     * 定义一个方法，对传递的文件路径进行合法性判断
     * 如果路径不是“c:\\a.txt”，那么我们就抛出文件找不到异常，告知方法的调用者
     * caution:
     * FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常
     * 可以使用throws继续声明抛出FileNotFoundException异常，让方法的调用者处理
     */
    //public static void readFile(String fileName) throws FileNotFoundException,IOException{
    public static void readFile(String fileName) throws IOException{
        if(!fileName.equals("c:\\a.txt"))
        {
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }


        /**
         * 如果传递的路径不是.txt结尾，那么我们就抛出IO异常，告知方法的调用者，文件的后缀名不对
         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("传递的文件路径是c:\\a.txt");
    }
}

异常处理的第二种方式：try…catch

package Exception;

import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * try...catch:异常处理的第二种方式，自己处理异常
 * 格式：
 * try{
 *     可能产生异常的代码
 * }catch（定义一个异常的变量，用来接收try中抛出的异常对象）{
 *     异常的处理逻辑，捕获异常之后，怎么处理异常
 *     一般在工作中，会把异常信息记录到一个日志当中
 * }
 * .....
 * catch(异常类名  变量名){
 *
 * }
 * 注意：
 * 1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
 * 2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕之后继续处理后面的代码
 * 如果try中没有产生异常，那么就不会执行catch中的异常处理逻辑，执行完try中的代码，继续执行try....catch之后的代码
 */

public class ExceptionCatchDemo {
    public static void main(String[] args) {
    try{
        readFile("d:\\a.txt");
    }catch(IOException e){
        System.out.println("catch-------传递的文件后缀不是.txt");
    }
        System.out.println("后缀代码");
    }

    /**
     * 如果传递的路径不是.txt结尾，那么我们就抛出IO异常，告知方法的调用者，文件的后缀名不对
     */
    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("传递的文件路径是c:\\a.txt");
    }
}

finally:

package Exception;

/**
 * try{
 *  *     可能产生异常的代码
 *  * }catch（定义一个异常的变量，用来接收try中抛出的异常对象）{
 *  *     异常的处理逻辑，捕获异常之后，怎么处理异常
 *  *     一般在工作中，会把异常信息记录到一个日志当中
 *  * }finally{
 *      无论是否出现异常都会执行
 *  }
 *  注意：
 *  1.finally不能单独使用，必须和try一起使用
 *  2.finally一般用于资源释放（资源回收）,无论程序是否出现异常，最后都要释放（IO）
 */

public class ThrowableDemo {

}

子父类异常关系：

public class ThrowableDemo {
    /**
     * 子父类异常：
     * 如果父类抛出了异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
     * 如果父类没有抛出异常，子类重写父类该方法时也不可以抛出异常，只能捕获处理，不能声明抛出
     * 注意：父类异常时什么样，子类异常就什么样
     */
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04() {}

}



 class Zi extends ThrowableDemo{
   //子类重写父类方法时，抛出和父类相同的异常
   public void show01() throws NullPointerException,ClassCastException{}
   //子类重写父类方法时，抛出父类异常的子类
   public void show02() throws IndexOutOfBoundsException{}
   //子类重写父类方法时，不抛出异常
   public void show03() {}

     //如果父类没有抛出异常，子类重写父类该方法时也不可以抛出异常，只能捕获处理，不能声明抛出
     public void show04() {
       try {
           throw new Exception("编译期异常");
       }catch (Exception e){
           e.printStackTrace();
       }
     }
}

自定义异常类：

package Exception;

/**
 * 自定义异常的类：
 * 格式：public class XXXException extends Exception | RuntimeException{
 *     添加一个空参的构造方法
 *     添加一个带异常信息的构造方法
 * }
 * 注意：
 * 1.自定义的异常类一般都是以Exception结尾，说明该类是一个异常类
 * 2.自定义异常类，必须继承Exception或者RuntimeException
 */

public class RigisterException extends Exception {
    public RigisterException(){

    }
    public RigisterException(String message){
        super(message);
    }
}

自定义异常类的应用：

package Exception;

import java.util.Scanner;

public class RegisterExceptionMainDemo {
    static String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名：");
        String username = sc.next();
        checkUsername(username);

    }

    public static void checkUsername(String username){
        for (String s : usernames) {
            if(username.equals(s)){
                try {
                    throw new RigisterException("该用户已经被注册");
                } catch (RigisterException e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
        System.out.println("注册成功");
    }
}