Java的自学之旅10

一.Java异常

1.Error:jvm系统内部错误，资源耗尽等严重情况

2.Exception:其他因编程错误或偶然的外在因数导致

（1）空指针访问

（2）试图读取不存在的文件

（3）网络连接中断

public class Test {
    public static void main(String[] args) {
        String[] strs=new  String[]{"a","b","c"};
        
        for (int i=0;i<4;i++){//0.1.2  没有第四位会报数
//组java.lang.ArrayIndexOutOfBoundsException越界异常（i<3正常输出）
            System.out.println(strs[i]);
        }
    }
}

 

        A a1=null;//引用变量a1没有指向对象指向nill什么都没有
//java.lang.NullPointerException空指针异常
        System.out.println(a1.i1);
    }
}
class A{
    int i1;
}

 

//        int i=0;
//        System.out.println(3/i);

 二.异常处理机制（捕获 抛出）

如果不写try会终止输出ok

int i=0;
try{//用try{}来括住一段可能出现的异常代码段
System.out.println(3/i);//异常会使程序中
} catch(Exception e){//当不知道是什么类型的异常时，可以直接用所有异常的父类Exception
    e.printStackTrace();
    e.getLocalizedMessage();
}
System.out.println("ok");

 

finally 的作用和用法

int i=0;
try{//用try{}来括住一段可能出现的异常代码段
    System.out.println(1);
System.out.println(3/i);//异常会使程序中
    System.out.println(2);
} catch(Exception e){//当不知道是什么类型的异常时，可以直接用所有异常的父类Exception
    e.printStackTrace();
    e.getLocalizedMessage();
    System.out.println(3);
}finally {//可写可不可，它是捕获异常的体系中最终一段会执行的部分，为了学习io操作和jdbc都会接触
    System.out.println(4);

}
System.out.println("ok");

 多次捕获

 String[] strs=new  String[]{"a","b"};
        A a2=null;
        try{//防止可能出现的异常
            //在捕获代码块中try()如果前面的代码有异常了就不报了
            System.out.println(strs[2]);
            System.out.println(a2.i1);

        }catch(ArrayIndexOutOfBoundsException e1){
            System.out.println(e1.getMessage());
            e1.printStackTrace();
        }catch(NullPointerException e2){
            System.out.println(e2.getMessage());
            e2.printStackTrace();
        }
        System.out.println("======");
    }
}
class A{
    int i1;
}

 三.声明抛出异常（子类重写父类的方法时，子类不能抛出比父类方法更大范围的异常）

public class Test1 {
    public static void main(String[] args) {//可以在main方法继续抛出异常throws Exception放在{}前
        //main方法抛出异常直接抛到虚拟机上去了，就在程序中不能处理
        B b =  new B();
        try {b.test();//throws在代码这抛出异常在调用方法获取处理
    }catch (Exception e){
            e.printStackTrace();
        }
}}
class B{
    int i;
    public void test() throws Exception{//可以使用throws在代码这抛出异常在调用方法处获取处理
            B b=null;
            System.out.println(b.i);
        }
    }

 注意事项

class B{
    int i;
//    NullPointerException的父类是 Exception
    public void test() throws NullPointerException{//可以使用throws在代码这抛出异常在调用方法处获取处理
            B b=null;
            System.out.println(b.i);
        }
    }
class C extends B{
    @Override
    public void test() throws NullPointerException {
        //  public void test() throws Exception  这里的NullPointerException就不能比父类更大的异常Exception
        super.test();
    }
}
四.人工抛出异常

public class Test1 {
    public static void main(String[] args) {
        B b =  new B();
        try {
            b.test1(-100);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {b.test();//throws在代码这抛出异常在调用方法获取处理
    }catch (Exception e){
            e.printStackTrace();
        }
}}

    int age;
    public void test1( int age) throws Exception {
        if (age>=0&&age<=125){
            this.age=age;
            System.out.println("年龄是："+this.age);
        }else {
            throw new Exception("年龄0到125之间");
        }

    }
}

 用户自定义异常类结合上面的输出比较

 （java提供的异常类一般是够用的只要特殊情况才可能需要自己编写）

public class Test1 {
    public static void main(String[] args) {//可以在main方法继续抛出异常throws Exception放在{}前
        //main方法抛出异常直接抛到虚拟机上去了，就在程序中不能处理
        B b =  new B();
        try {
//            b.test1(-100);
            b.test2(-100);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {b.test();//throws在代码这抛出异常在调用方法获取处理
    }catch (Exception e){
            e.printStackTrace();
        }
}}
class B{
    int i;
//    NullPointerException的父类是 Exception
    public void test() throws NullPointerException{//可以使用throws在代码这抛出异常在调用方法处获取处理
            B b=null;
            System.out.println(b.i);
        }
        int age;
        public void test1( int age) throws Exception {
            if (age>=0&&age<=125){
                this.age=age;
                System.out.println("年龄是："+this.age);
            }else {
                throw new Exception("年龄0到125之间");
            }
        }
        public void test2( int age) throws MyException {
            if (age>=0&&age<=125){
                this.age=age;
                System.out.println("年龄是："+this.age);
            }else {
                throw new MyException("年龄0到125之间");
            }
    }
class C extends B{
    @Override
    public void test() throws NullPointerException {
        //  public void test() throws Exception  这里的NullPointerException就不能比父类更大的异常Exception
        super.test();
    }
}
class MyException extends Exception{
    public MyException(String msg){
        super(msg);
    }
}}

五.集合

1.集合类存放于java.util包中，是一个用来存放对象的容器

2.java集合可分为Set（无序，不可重复的集合） List（有序，可重发集合） Map（具有映射关系的集合）三种体系（在jdk5之后增加了泛型，Java集合可以记住容器中对象的数据类型）

HashSet

HashSet是Set接口的典型实现，大多数时候用Set集合时都是使用这个实现类，我们大对数时候说的set集合指的都是HashSet

HashSet按Hash算法来存储集合中的元素，因此很好的存取和查找性能

HashSet具有以下特点：不能保证元素的排列顺序，不可重复，HashSet不是线程安全的，集合元素可以是null

当向HashSet集合中存入一个元素时，HashSet会调用改对象的HashCode（）方法得到该对象的HashCode值，然后根据HashCode对象在HashSet中的存储位置。

 如果两个元素的equals()方法返回值true，但它们的HashCode()返回值不限等，HashSet将会把它们存储在不同的位置，但依然可以添加成功

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

public class Test2 {
    public static void main(String[] args) {
        Set set=new HashSet<>();
        set.add(1);//添加
        set.add("b");
        System.out.println(set);
        set.remove(1);
        System.out.println(set);
        System.out.println(set.contains("a"));//是否包括
        set.clear();
        System.out.println(set);
        set.add("z");
        set.add("x");
        set.add("c");
        set.add("v");
        set.add(1);

        set.add("v");//值是不重复的
        set.add(null);
        System.out.println(set);
        //使用迭代器遍历集合
        Iterator it=set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
// for each迭代集合
        for (Object obj1:set){//set的每一个值赋值给obj1全部完成
            System.out.println(obj1);
        }
        System.out.println(set.size());//获取集合元素的个数
        //如果想要让集合只能存同样类型的对象，怎么做
        //使用泛型
        Set<String> set2=new HashSet<String>();//指定string类型
        set2.add("dasds");
//        set2.add(1);//类型不符无法添加
    }
}

上述的应用方法输出：

 TreedSet

 TreedSet是SortedSet接口实现类， TreedSet可以确保集合元素处于排序状态。

 TreedSet支持两种排序方法：自然排序和制定排序。默认情况下，

 TreedSet采用自然排序。

代码举例

public class Test3 {
    public static void main(String[] args) {
        Set<Integer> set=new TreeSet<Integer>();//TreeSet自然排序必须放入同样类型的对象
        set.add(5);
        set.add(2);
        set.add(1);
        set.add(7);
        System.out.println(set);
        //使用迭代器遍历集合
        Iterator it=set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
// for each迭代集合
        for (Integer i:set){//set的每一个值赋值给obj1全部完成
            System.out.println(i);
        }

输出结果

 下面时定制排序方法

        Person p1=new Person("zhang",221);
        Person p2=new Person("zhang1",22);
        Person p3=new Person("zhang2",23);
        Person p4=new Person("zhang3",224);

        Set< Person> set1=new  TreeSet< Person>(new Person());
        set1.add(p1);
        set1.add(p2);
        set1.add(p3);
        set1.add(p4);
        for ( Person p:set1){
            System.out.println(p.name+" "+p.age);
        }

    }
}
class Person implements Comparator<Person> {//把Person对象存到TreeSet中并且按照年龄排序
    int age;
    String name;
    public Person(){}
    public Person(String name, int age){
        this.age=age;
        this.name=name;
    }
    @Override
    public int compare(hellojava.day10.Person o1, hellojava.day10.Person o2) {//年龄正序（定制排序）
        if (o1.age>o2.age){//倒叙<可实现
            return 1;
        }else if(o1.age<o2.age){
            return -1;
        }else {
            return 0;
        }

    }
}

输出结果

 List与Arry List

List代表一个元素有序且可重复的集合，集合中的每个元素都有其对应的顺序索引；

List允许使用重复元素，可以通过索引来访问指定位置的集合元素

List默认按元素的添加顺序设置元素的索引

List集合里添加了一些根据索引来操作集合元素的方法

import java.util.ArrayList;
import java.util.List;


public class Test4 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("b");//索引下标0往下类推
        list.add("d");
        list.add("c");
        list.add("a");
        list.add("d");//可重
        System.out.println(list);
        System.out.println(list.get(2));//可以通过索引来访问指定位置的集合元素

        list.add(2,"f");//根据索引来操作集合元素的方法
        System.out.println(list);

        List<String> l=new ArrayList<String>();
        l.add("d");
        l.add("dd");
//        list.addAll(2,1);不兼容问题使用不了
            System.out.println( list);
        System.out.println( list.indexOf("d"));//获取指定元素第一次出现的下标
        System.out.println( list.lastIndexOf("d"));//获取指定元素最后一次出现的下标
        list.remove(2);//根据下标移除元素
        System.out.println( list);
        list.set(2,"ff");//根据下标修改元素
        System.out.println( list);
        List<String>subList= list.subList(2,4);//根据下标起始位置截取元素包含开始时的索引不包含结束
        System.out.println(subList);
        System.out.println(list.size());//长度
    }
}

输出

 关于插入那个兼容性问题思考了好久没有解决希望有厉害的小伙伴提供帮助噢！！阿里噶陀

Map

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的Key另外一组用于保存Map里的Value

Map中的key和value都是可以是任何引用类型的数据

Map中的key不允许重复，即使同一个Map对象的任何两个Map通过equals方法进行比较返回false

key和value之间存在单向一对一关系，即通过指定的key总能找到唯一的确定的value

得配合代码好好理解：

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

public class Test5 {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<String,Integer>();
        map.put("b",1);
        map.put("c",2);
        map.put("e",2);
        System.out.println(map);
        System.out.println(map.get("b"));
        map.remove("c");
        System.out.println(map.containsKey("c"));
        //遍历map集合
       Set<String> keys =map.keySet();//获取map合集的key的集合
       map.values();//获取所values有值
        for (String key:keys ){
            System.out.println("key"+key+",value:"+map.get(key));
        }

        //通过  map.entrySet();
        Set<Map.Entry<String,Integer>>entrys=map.entrySet();
        for (Map.Entry<String,Integer>en:entrys){
            System.out.println("key"+en.getKey()+",value:"+en.getValue());

        }
    }
}

 

TreeMap

 

//        TreeMap的排序是自动的
        Map<Integer,String> map1=new TreeMap<Integer,String>();
        map1.put(4,"a");
        map1.put(3,"a");
        map1.put(1,"a");
        map1.put(2,"a");
        System.out.println(map1);

        Map<String,String> map2=new TreeMap<String,String>();
        map2.put("a","a");
        map2.put("b","a");
        map2.put("w","a");
        map2.put("e","a");
        map2.put("1","a");
        map2.put("d","a");
        map2.put("10","a");
        System.out.println(map2);
    }
}

 操作集合的工具类：Collections

public class Test6 {
    public static void main(String[] args) {
        List <String> list=new ArrayList<String>();
        list.add("b");
        list.add("xb");
        list.add("sb");
        list.add("q");
        list.add("5");
        System.out.println(list);
        Collections.reverse(list);//反转元素的顺序
        System.out.println(list);
        Collections.shuffle(list);//随机元素的顺序
        System.out.println(list);
        Collections.sort(list);//升序元素的顺序
        System.out.println(list);
        
    }
}

 

package hellojava.day10;

import java.util.*;

public class Test6 {
    public static void main(String[] args) {
        List <String> list=new ArrayList<String>();
        list.add("b");
        list.add("xb");
        list.add("sb");
        list.add("q");
        list.add("q");
        list.add("5");
        System.out.println("元素正常输出"+list);
        Collections.reverse(list);//反转元素的顺序
        System.out.println("反转元素的顺序"+list);
        Collections.shuffle(list);//随机元素的顺序
        System.out.println("随机元素的顺序"+list);
        Collections.sort(list);//升序元素的顺序
        System.out.println("升序元素的顺序"+list);

        Collections.swap(list,2,3);//指定位置元素交换
        System.out.println("指定两个元素交换位置后"+list);


        System.out.println("元素的顺序最大的"+ Collections.max(list));
        System.out.println( "元素的顺序最小的"+Collections.min(list));

        Student s=new Student(14,"张三");
        Student s1=new Student(12,"张2三");
        Student s2=new Student(16,"张3三");
        Student s3=new Student(11,"张4三");


        List<Student>stus=new ArrayList<Student>();
        stus.add(s);
        stus.add(s1);
        stus.add(s2);
        stus.add(s3);

        Student m= Collections.max(stus,new  Student());
        System.out.println("输出年龄最大的"+m.name+","+m.age);//输出年龄最大


        Student n= Collections.min(stus,new  Student());
        System.out.println("输出年龄最小的"+n.name+","+n.age);//输出年龄最小的
        System.out.println("指定元素出现频率"+Collections.frequency(list,"p"));//出现的频率
        Collections.replaceAll(list,"p","pp");//指定替换
        System.out.println("指定替换后"+list);

        System.out.println("名字=================排序'");
     for (Student stu:stus){

         System.out.println(stu.name+","+stu.age);
     }
        Collections.sort(stus,new Student());
        System.out.println("'升=================序'");
        for (Student stu:stus){
            System.out.println(stu.name+","+stu.age);
        }

    }
}
class Student implements Comparator<Student>{
    int age;
    String name;
    public Student(){}
    public Student(int age, String name){
        this.age=age;
        this.name=name;

    }


    @Override
    public int compare(Student o1, Student o2) {//根据升序排列
        if (o1.age>o2.age){
            return 1;
        }else if (o1.age<o2.age){
            return -1;
        }else {
        return 0;}
    }
}

 今天的快乐精心设计，希望大家喜欢，咱们以后继续延续快乐时光！！！