2021-06-02

学习java第十八天

Collection集合概述

1.Java数组的长度是固定的，为了使程序能够方便地存储和操作数目不固定的一组数据，JDK类库提供了Java集合

2.与数组不同的是，集合中不能存放基本类型数据，而只能存放对象的引用

3.数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

Collection集合

1.有序的集合（存储和取出元素顺序相同）

2.允许存储重复的元素

3.有索引，可以使用普通的for循环遍历

Collection常用功能

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合( List和Set）通用的一些方法，这些方法可用于操作所有的单列集合。方法如下:

• public boolean add(E e)把给定的对象添加到当前集合中。
• public void clear （）:清空集合中所有的元素。
• pub1ic boolean remove (E e):把给定的对象在当前集合中删除。
• public boolean contains (E e):判断当前集合中是否包含给定的对象。
• public boolean isEmpty ( ) :判断当前集合是否为空。
• public int size ( ) :返回集合中元素的个数。
• public object[ ] toArray ( ）: 把集台中的元素，存储到数组中。

package demo1;

import java.util.Collection;
import java.util.HashSet;

public class collection {
public static void main(String[] args) {
	Collection<String> coll=new HashSet<>();//体现了多态
	System.out.println(coll);
	
	boolean b1=coll.add("张三");
    System.out.println(b1);
    System.out.println(coll);
    coll.add("李四");
    coll.add("李四");
    coll.add("王五");
    coll.add("赵六");
    System.out.println(coll);
    
    boolean b2=coll.remove("王五");
    System.out.println(b2);
    System.out.println(coll);
    
    boolean b3=coll.contains("赵六");
    System.out.println(b3);
    
    boolean b4 =coll.contains("王五");
    System.out.println(b4);
    boolean b5=coll.isEmpty();
    System.out.println(b5);
    
    int b6=coll.size();
    System.out.println(b6);
    
    Object[] arr=coll.toArray();
    System.out.println(arr[0]);
   
    coll.clear();
    System.out.println(coll);
    b5=coll.isEmpty();
    System.out.println(b5);
}
}

Iterator迭代器

lterator接口
在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问(即遍历)，ColTection中的元素，因此Iterator对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成选代操作，下面介绍一下获取迭代器的方法：

●public Iterator iterator()：获取集合对应的迭代器，用来遍历集合中的元素的。

●送代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

lterator接口的常用方法如下：

●public E next()：返回迭代的下一个元素。
●public boolean hasNext()：如果仍有元素可以迭代，则返回true。

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

public class Demo02Iterator {

    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("布莱迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");

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

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

        System.out.println("=======");

        //增强型for循环
        for(String s:coll)
            System.out.println(s);

        System.out.println("=======");
        int[] arr1={45,6,7,8,9,10};
        //第一种写法
//        for(int i=0;i<arr1.length;i++)
//        {
//            System.out.println(arr1[i]);
//        }
        for(int i:arr1)
        {
            System.out.println(i);
        }
    }
}

异常
java中异常分类

Throwable类有两个直接子类：

（1）Exception：出现的问题是可以被捕获的

（2）Error：系统错误，通常由JVM处理

异常的处理

1、通过try…catch语句块来处理

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。
如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

package Demo02;

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

public class Demo02Exception {
	public static void main(String[] args) {
		//编译期间异常
		SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
		
		Date date =null;
		//运行期异常
		System.out.println("第一句测试");
		try {
			date = sdf.parse ("2021-05-11");
		} catch (ParseException e) {
			
			e.printStackTrace();
		}
		
		System.out.println(date);
		System.out.println("第二句测试");
		
		//运行期异常
		int [] arr= {1,122,3};
		System.out.println(arr[0]);
		//有问题，但是不会提示，因为编译能够通过，在执行的时候才会有异常
		try {
			System.out.println(arr[2]);

		}catch(Exception e) {
			System.out.println("第一句测试");
			System.out.println(e);

		}
		//error  错误
		int [] arr2= new int[1024*10000000];
		System.out.println("后续代码");
	}
}

2、另外，也可以在具体位置不处理，直接抛出，通过throws/throw到上层再进行处理，具体的，如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

package demo2;

public class Throw {
public static void main(String[] args) {
	int[] arr=null;
	int e=getElement(arr,3);
	System.out.println(e);
}

private static int getElement(int[] arr, int index) {
	if(arr==null) {
		throw new NullPointerException("传递的数组值是NULL");
	}
	if(index<0||index>arr.length-1) {
		throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的正常使范围");
	}
	int ele=arr[index];
	return 0;
}
}

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

public class Demo03Throws {
    public static void main(String[] args) throws FileNotFoundException,IOException{
        readFile("c:\\a.txt");
        System.out.println("后续代码");

    }
    public static void readFile(String filename) throws FileNotFoundException,IOException{
        if(!filename.equals("c:\\a.txt"))
        {
            throw new FileNotFoundException("传递的文件不是c:\\a.txt");
        }
        if(!filename.endsWith(".txt"))
        {
            throw new IOException("文件名后缀有无");

        }
        System.out.println("文件正确");
    }
}

3、finally关键字

• finally 关键字用来创建在 try 代码块后面执行的代码块。
• 无论是否发生异常，finally 代码块中的代码总会被执行。
• 在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
• finally 代码块出现在 catch 代码块最后