Java学习日记基础篇(九) —— 集合框架,泛型,异常

2021年09月15日 阅读数:1
这篇文章主要向大家介绍Java学习日记基础篇(九) —— 集合框架,泛型,异常,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

集合框架

  有事咱们会须要一个可以动态的调整大小的数组,好比说要添加新员工可是数组已经满了,而且数组的大小是在定义的时候定死的,因此咱们就须要一个可以动态调整大小的数组或者用链表解决,而java中提供了这样一组数组,名为集合类。(有事仍是须要链表来解决一些问题的)java

    

重要的就是linkedlist,arraylist,vector,hashset,hashmap数据库

 从图中能够看出Java的集合类主要有如下几种:编程

  • List结构的集合类 —— ArrayList类LinkedList类Vector类Stack类
  • Map结构的集合类 —— HashMap类HashTable类
  • Set结构的集合类 —— HashSet类Hashtable类
  • Queue结构的集合 —— Queue接口

List类——列表结构

ArrayList和Vector的区别数组

  1. 同步性:Vector是同步的而ArrayList则是异步的。因此ArrayList是不安全的可是效率高。
  2. 数据增加:Vector会增加一倍的原数组的大小,ArrayList会增加原来的50%,因此集合所占的空间要比实际的需求要大

ArrayList类

//使用ArrayList类就要引入一个包
import java.util.*;
public class test1 {
    public static void main(String[] args) {
        //定义一个ArrayList对象
        ArrayList al = new ArrayList();
        
        //显示大小,用ArrayList类提供的size方法
        System.out.println("大小是:"+al.size());
        
        //向al中加入数据(类型是Object,Java中全部的类都是从Object中集成下来的,这意味着集合中能够放全部类型的类)
        //建立一个职员
        Clerk clerk1 = new Clerk("松江", 50, 1000);
        Clerk clerk2 = new Clerk("吴用",45,1200);
        //将clerk1加入到al中
        al.add(clerk1);//默认加载到尾部
        al.add(clerk2);
        System.out.println("大小是:"+al.size());
        
        //如何访问al中对象(数据)
        //访问第一个对象
        //Clerk temp = al.get(0);//get()返回的对象是object类型的,是clerk类型的父类,因此会报错
        //强制转换
        Clerk temp = (Clerk)al.get(0);
        System.out.println("第一我的的名字是:"+ temp.getName());
        
        //从al中删除一个对象
        al.remove(1);
    }
}
class Clerk
{
    private String name;
    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 float getSal() {
        return sal;
    }
    public void setSal(float sal) {
        this.sal = sal;
    }
    private int age;
    private float sal;
    public Clerk(String name,int age,float sal)
    {
        this.name = name;
        this.age = age;
        this.sal = sal;
    }
}
添加,遍历和删除对象

用ArrayList来实现一个简单的员工管理系统安全

LinkedList类

import java.util.*;
public class test4 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList l1 = new LinkedList();
        Emp emp1 = new Emp("sa01","aa",1.2f);
        Emp emp2 = new Emp("sa01","bb",1.2f);
        l1.addFirst(emp1);//直接往前加,在链表的最前边
        l1.addFirst(emp2);
        for(int i=0;i<l1.size();i++)
        {
            System.out.println(((Emp)l1.get(i)).getName());
        }
        l1.remove(0);//删除也是原来的命令
        for(int i=0;i<l1.size();i++)
        {
            System.out.println(((Emp)l1.get(i)).getName());
        }
    }
}
可以把后添加的数放到前边

Vector类

 

Stack类

 

Map结构的集合类

HashMap和Hashtable的区别网络

  1. 历史缘由:Hashtable是基于陈旧的Dictonary类的,HashMap是java 1.2引进的Map接口的一个实现 
  2. 同步性:HashTable是同步的。这个类中的一些方法保证了Hashtable中的对象是线程安全的。而HashMap则是异步的,所以HashMap中的对象并非线程安全的。由于同步的要求会影响执行的效率,因此若是不须要线程安全的集合那么使用HashMap是一个很好的选择,这样能够避免因为同步带来的没必要要的性能开销,从而提升效率
  3. 值:HashMap可让你将空值做为一个表的条目的key或value,可是Hashtable是不能放入空值的

HashMap类

 1 public class test7 {
 2     public static void main(String[] args)
 3     {
 4         //建立一个HashMap对象
 5         HashMap hm = new HashMap();
 6         Emp emp1 = new Emp("s001","aaa",12.3f);
 7         Emp emp2 = new Emp("s002","bbb",12.3f);
 8         Emp emp3 = new Emp("s003","ccc",2.3f);
 9         
10         
11         //将emp放入到hm中
12         //以键值对的形式存入的,查询的时候能够经过是否有指定键或值来查找
13         //键是key,值是value
14         hm.put("s001", emp1);
15         hm.put("s002", emp2);            
16     }
17 }
建立一个HashMap对象

HashMap的对象的键的值是惟一的框架

public class test7 {
    public static void main(String[] args)
    {
        //建立一个HashMap对象
        HashMap hm = new HashMap();
        Emp emp1 = new Emp("s001","aaa",12.3f);
        Emp emp2 = new Emp("s002","bbb",12.3f);
        Emp emp3 = new Emp("s003","ccc",2.3f);
        
        
        //将emp放入到hm中
        //以键值对的形式存入的,查询的时候能够经过是否有指定键或值来查找
        //键是key,值是value
        hm.put("s001", emp1);
        hm.put("s002", emp2);
        hm.put("s002", emp3);//emp3会替换掉emp2,不键容许重复
        
        //若是你要查找编号是s002的人
        if(hm.containsKey("s002"))//有这个键就返回真,没有就返回假
        {
            System.out.println("有这个员工");
            //如何取出
            Emp emp=(Emp)hm.get("s002");
            System.out.print("名字:"+emp.getName());
        }
        else{System.out.println("没有");}    
    }
}
在HashMap类中查找对象

遍历集合中全部的对象异步

import java.util.*;
public class test7 {
    public static void main(String[] args)
    {
        //建立一个HashMap对象
        HashMap hm = new HashMap();
        Emp emp1 = new Emp("s001","aaa",12.3f);
        Emp emp2 = new Emp("s002","bbb",12.3f);
        Emp emp3 = new Emp("s003","ccc",2.3f);
            
        //将emp放入到hm中
        hm.put("s001", emp1);
        hm.put("s002", emp2);
        hm.put("s003", emp3);//emp3会替换掉emp2,不键容许重复            
        
        //遍历HashMap中全部的key和value
        //用迭代器Iterator
        Iterator it = hm.keySet().iterator();
        
        //hasNext返回一个boolean
        while(it.hasNext())
        {
            //取出key
            String key = it.next().toString();
            //经过key取出value
            Emp emp =(Emp)hm.get(key);
            System.out.println("名字:"+emp.getName());
        }
    }
}
遍历集合中的全部对象

  注意:取出来的是乱序的,因此这是它的一个缺点ide

Hashtable类

 

总结

java的设计者给咱们提供了这些集合类,在后面编程中式至关有用的,具体何时用什么集合,要根据咱们刚才分析的集合一同来选取。函数

  1. 若是要求线程安全,使用Vector、Hashtable
  2. 若是不要求线程安全,应使用ArrayList,LinkedList,HashMap
  3. 若是要求有--键值对,则使用HashMap,Hashtable
  4. 若是数据量很大,又要考虑线程安全用Vector

 泛型

  泛型的本质是参数化类型,也就是说全部操做的数据类型被指定成为一个参数。这种参数类型能够在类,接口和方法的建立中,分别称为泛型类、泛型接口、泛型方法。

  Java引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全,而且全部的强制转换都是自动和隐式的,提升代码的重用率。

 案例:取出集合中的对象的时候须要进行强制的类型转换,不然会报错

import java.util.*;

 * 功能:了解泛型的必要性
 * 时间:2018.10.26
 
public class test4 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList al = new ArrayList();
        Dog dog1 = new Dog();
        //放入到集合中
        al.add(dog1);
        //取出
        Dog temp = (Dog)al.get(0);//要有一个强转类型
    }
}

class Dog
{
    private String name;
    private int age;
    
    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;
    }
    
}
泛型

     

  咱们在建立一个猫类,能够看出猫类中属性的数据类型和狗类的彻底相同,可是表达的意义却不相同,这会引起一个常见的错误,dog类不能转换成dog类型

package project1;
import java.util.*;

 * 功能:了解泛型的必要性
 * 时间:2018.10.26
 
public class test4 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList al = new ArrayList();
        Dog dog1 = new Dog();
        //放入到集合中
        al.add(dog1);
        //取出
        //Dog temp = (Dog)al.get(0);//要有一个强转类型
        Cat temp = (Cat)al.get(0);    //这样写也不会报错,
        //但编译的时候会出错--类型转换出错
    }

}

class Dog
{
    private String name;
    private int age;
    
    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;
    }
    
}

class Cat
{
    private String color;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    private int age;
}
类型转换出错

    

    

    

 用泛型类解决这个问题

    

    

泛型的经典用法——Java中的反射机制

 1 public class test5 {
 2 
 3     /**
 4      * @param args
 5      */
 6     public static void main(String[] args) {
 7         // TODO Auto-generated method stub
 8         Gen<String> gen1 = new Gen<String>("aaa");//括号内填写字符串类型
 9         gen1.showTypeName();
10         Gen<Integer> gen2 = new Gen<Integer>(1);//括号内是Integer类型
11         gen2.showTypeName();
12         
13         //
14         Gen<Bird> gen3 = new Gen<Bird>(new Bird());//括号内是本身新new的Bird类型
15         gen3.showTypeName();
16         
17     }
18 
19 }
20 
21 //定义一个鸟类
22 class Bird
23 {
24     public void testt1()
25     {
26         System.out.println("aa");
27     }
28     public void count(int a,int b)
29     {
30         System.out.println(a+b);
31     }
32 }
33 class Gen<T>    //T是本身定义的一个类,传入的是什么类型就是什么类型
34 {
35     private T o;
36     //构造函数
37     public Gen(T a)
38     {
39         o=a;
40     }
41     //获得T的类型名称
42     public void showTypeName()
43     {
44         System.out.println("类型是:"+o.getClass().getName());
45     }
46     
47 }
48 
49 结果:
50 类型是:java.lang.String
51 类型是:java.lang.Integer
52 类型是:project1.Bird
初识反射机制

  经过反射机制能够拿到类的不少信息

import java.lang.reflect.Method;
public class test5 {

    /**
     * @param args
     */
    public static void main(String[] args) {

        
        //
        Gen<Bird> gen3 = new Gen<Bird>(new Bird());//括号内是本身新new的Bird类型
        gen3.showTypeName();
        
    }

}

//定义一个鸟类
class Bird
{
    public void testt1()
    {
        System.out.println("aa");
    }
    public void count(int a,int b)
    {
        System.out.println(a+b);
    }
}
class Gen<T>    //T是本身定义的一个类,传入的是什么类型就是什么类型
{
    private T o;
    //构造函数
    public Gen(T a)
    {
        o=a;
    }
    //获得T的类型名称
    public void showTypeName()
    {
        System.out.println("类型是:"+o.getClass().getName());
        
        //经过反射机制,咱们能够获得T这个类型的不少信息(好比获得成员函数名)
        Method []m = o.getClass().getDeclaredMethods();
        //这个method须要导包
        
        for(int i=0;i<m.length;i++)
        {
            System.out.println("函数名:"+m[i].getName());
        }
    }
}


运行结果:
类型是:project1.Bird
函数名:count
函数名:testt1
利用反射机制拿类的信息

 泛型的优势

  1. 类型安全
  2. 向后兼容
  3. 层次清晰
  4. 性能较高用GJ(Generic in Java泛型Java)编写的代码能够为java编译器和虚拟机带来更多的类型信息,这些信息对java程序作进一步优化提供条件着(之后就明白了)

异常处理

  基本概念:当出现程序没法控制的外部环境问题(用户提供的文件不存在,文件内容损坏,网络不可用。。。)时,Java就会用异常对象来描述。

Java中用两种方法处理异常:

  一、在发生异常的地方直接处理

  二、将异常抛给调用者,让调用者处理

异常分类

  1. 检查性异常:java.lang.Exception
  2. 运行期异常:java.lang.RuntimeException
  3. 错误:java.lang.Error

  顶层都是java.lang.Throwable集成而来,检查性异常,运行期异常,错误都是这个类的子孙类。

  • 检查性异常(也叫编译异常):程序正确,但由于外在的环境条件不知足引起。例如:用户错误及I/O问题。这不是程序自己的逻辑错误。对于商用软件系统,程序开发者必须考虑并处理这个问题。Java编译器强制要求处理这类异常,若是不能捕获这类异常,程序将不能被编译。
  • 运行期异常:这意味着程序存在bug,如数组越界,0被除,入参不知足规范等等,这类异常须要更改程序来避免,Java编译器要求强制处理这类异常。
  • 错误:通常不多见,也很难经过程序解决。它可能源于程序的bug,但通常更可能源于环境问题,如内存耗尽,杀毒软件太sd。错误在程序中无需处理,而由运行环境处理。

 案例:

package project1;
//要使用打开文件的类,就要引入IO包
import java.io.*;
import java.net.*;

public class test6 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //检查异常 1.打开一个不存在的文件
        FileReader fr = new FileReader("d:\\a.text");
        
        //2.链接一个不存在的ip端口
        Socket s = new Socket("192.168.1.23" , 78);
        
    }

}
检查性异常

      

    

运行期异常排错要比检查性异常可贵多

public class test7 {
    public static void main(String[] args) {
        //1.除0操做
        int a=4/0;

        //2.数组越界
        int arr[] = {1,2,3};
        System.out.println(arr[123]);
    }

}
运行期异常

错误

 异常的解决方法——捕获异常以及将异常抛出去

捕获异常

 1 import java.io.*;
 2 public class test8 {
 3     public static void main(String[] args) {
 4         try {
 5             FileReader fr=new FileReader("d:\\aa.text");
 6         } 
 7         catch (Exception e)//Exception是最大的异常 
 8         {
 9             // 把异常输出出来,易于排错
10             e.printStackTrace();
11         }
12         
13         //最小捕获--有什么异常就捕获什么异常
14         try {
15             FileReader fr=new FileReader("d:\\aa.text");
16         } 
17         catch (FileNotFoundException e)        //
18         {
19             // 把异常输出出来,易于排错
20             e.printStackTrace();
21         }
22     }
23 }
捕获异常

若是是最小捕获异常的话一次只能捕获一个异常

    

import java.io.*;
import java.net.Socket;
public class test8 {
    public static void main(String[] args) {
        
        //最小捕获--有什么异常就捕获什么异常
        try {
            FileReader fr=new FileReader("d:\\aa.text");
            Socket s = new Socket("192.168.1.23",88);//由于上局话出现异常后直接就跳到下面去了,因此这句话不会被执行
        } 
        catch (FileNotFoundException e)        
        {
            e.printStackTrace();
        }
        catch(IOException e2)
        {
            e2.printStackTrace();    //但这句话不会执行
        }
    }
}
解决方法

 

最大捕获则没有问题

    

还能够用getMessage方法输出信息,可是输出的内容简单,不会显示是哪一行出错

import java.io.*;
import java.net.Socket;
public class test8 {
    public static void main(String[] args) {
        
        //最小捕获--有什么异常就捕获什么异常
        try {
            FileReader fr=new FileReader("d:\\aa.text");
        } 
        catch (FileNotFoundException e)        
        {
            //输出错误信息
            e.printStackTrace();
            System.out.println("message:=" + e.getMessage());
            //处理方法
        }
    }
}
没什么价值的信息

finally

   他是一个万能保险,常用。若是把finally块置放在try...catch...语句以后,finally块的语句通常都会获得执行,它至关于一个万能的保险,即便前面的try块发生异常,而又没有对应的异常的catch块,finally块将立刻执行。

  如下状况finally块将不会被执行

  1. finally块中发生了异常
  2. 程序所在线程死亡
  3. 在前面的代码中用了System.exit();   退出系统
  4. 关闭cpu

 打开文件后,不关闭是没法保存的

import java.io.*;
import java.net.Socket;
public class test9 {
    public static void main(String[] args) {
        
        FileReader fr=null;
        try {
            fr=new FileReader("d:\\aa.txt");
            Socket s = new Socket("192.168.1.1",78);
        } 
        catch (Exception e)        
        {
            e.printStackTrace();
        }
        //此时会出现这样一种状况
        //d盘中有这个文件,文件被打开了,可是没有这台主机,因此下面的会抛出异常
        //这就形成了文件会一直打开的状态,文件不关闭是没法进行保存的
        //这是就须要finally语句,若是没有特殊状况它是必定会执行的
        finally{
            System.out.println("进入finally");
            //这个语句块,无论有没有出现异常,都会执行
            //通常来讲,把须要关闭的资源,好比说文件,打开的连接(数据库),内存等等
            if(fr!=null)    //若是文件不是空,就关闭它
            {
                try {
                    fr.close();//它仍是有个异常,咱们把它也try..catch掉
                } catch (Exception e2)  {
                    // TODO: handle exception
                    e2.printStackTrace();
                }
            }
        }
    }
}
finally的用法

注意:只有没有catch,只有try和finally也是能用的,可是通常没人这么用

 抛出异常——将异常抛给调用者

 通常不会这么用

import java.io.FileReader;
public class test91 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Father father = new Father();
        father.test1();
    }
}

class Father
{
    private Son son = null;
    public Father()
    {
        son = new Son();
        
    }
    public void test1()
    {
        System.out.println("ellie");
//        son.test2();//此时这个方法会抛出一个异常
        try {
            son.test2();
        } catch (Exception e) {
            // TODO: handle exception
            System.out.println("父亲在处理");
            e.printStackTrace();
        }
    }
}

class Son
{
    public void test2() throws Exception    //扔出去
    {
        FileReader fr = null;
        //fr = new FileReader("d:\\dd.txt");//不try catch这条语句作处理,程序是没法执行的
        //若是不想处理它,就把他扔出去
        fr = new FileReader("d:\\dd.txt");
    }
}
抛出异常

报错信息——提示好几个地方有错的时候,只看最前面的错误就能够了