JAVA基础(五)

集合的由来?

面向对象语言对事务的体现都是以对象的形式，所以为了方便对多个对象的操作，JAVA就提供了集合类

集合和数组的区别?

数组	集合
长度固定	长度可变
存储基本数据类型	只可以存储对象

Collection集合的功能概述?

Collection表示一组对象，这些对象也成为collection元素。
一些collection允许有重复的元素，另一些不允许有重复的元素。
一些collection是有序的，另一些是无序的。

Collection集合存储字符串并遍历?(迭代器)

public static void collectiontest() {
Collection<String> col=new ArrayList();
col.add("eee");
col.add("cvv");
col.add("nvj");
Iterator it = col.iterator(); //迭代器
while(it.hasNext()) {
String s =(String) it.next();
System.out.println(s);
}

Collection集合存储自定义对象并遍历?(迭代器)

public static class Person{
        private String name;

        public Person() {
            super();
        }
        public Person(String name) {
            super();
            this.name = name;
        }

        public String getName() {
            return name;
        }

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

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection c=new ArrayList();
        Person p1=new Person("呵呵哒");
        Person p2=new Person("萌萌哒");
        c.add(p1);
        c.add(p2);
        Iterator It=c.iterator();
        while(It.hasNext()) {
            Person s=(Person)It.next();
            System.out.println(s.getName());
        }

List集合的特有功能?

List是有序的collection。可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的证书索引访问元素，并搜索列表中的元素。

List接口成员方法

void add(int index,E element)//添加元素
E remove(int index)//删除元素
E get(int index)//获得元素
E set(int index,E element)//修改元素
ListIterator listIterator()//迭代器
boolean hasPrevious()//ListIterator的方法，用于反向遍历链表,与hasNaxt()方法相同
E previous()//ListIterator的方法，用于反向遍历链表，与next()方法相同返回越过的对象
ConcurrentModificationException//在每个迭代器的方法开始处检查自己改写操作的计数值是否与集合的改写操作计数值一致；如果不一致，抛出ConcurrentModificationException

List集合存储字符串并遍历?(迭代器和普通for)

public static void ListTest() {
    List list=new ArrayList();
    list.add("呵呵呵");
    list.add("好累啊");
    list.add("努力吧");
    for(int i=0;i<list.size();i++) {
        System.out.println("这是for循环的："+list.get(i));
    }
    ListIterator litor=list.listIterator();
    while(litor.hasNext()) {
        String s=(String)litor.next();
        System.out.println("这是ListIterator的："+s);
    }
}

并发修改异常出现的原因?解决方案?

A: 出现的现象
迭代器遍历集合，集合修改集合元素
B: 原因
迭代器是依赖于集合的，而集合的改变迭代器并不知道。
C: 解决方案
a:迭代器遍历，迭代器修改(ListIterator)
元素添加在刚才迭代的位置
b:集合遍历，集合修改(size()和get())
元素添加在集合的末尾

常见的数据结构的特点?

栈：Stack<T> 后进先出。
队列：Queue<T> 先进先出。队列在声明的时候可以是泛型。
数组：只合适查询比较频繁，增删较少的情况，对于int类型数据，默认初始值为1;
链表：单链表和双链表，LinkedList list=new LinkedList(),出了头结点，每个节点包含一个数据域和一个指针域，除了头、尾节点，每个节点的指针指向下一个节点。

List集合的子类特点

ArrayList:底层数据结构是数组，查询快，增删慢。线程不安全，效率高。
Vector:底层数据结构是数组，查询快，增删慢。线程安全，效率低。特有addElement(E obj),E elementAt(int index),Enumeration element()三种方法。
LinkedList:底层数据结构是链表，查询慢，增删快，线程不安全，效率高。特有addFirst(E e)、addLast(E e),getFirst()、getLast(),removeFirst()、removeLast() 6中方法。

LinkedList练习

A:LinkedList存储字符串并遍历
B:LinkedList存储自定义对象并遍历

public static void main(String[] args) {
    // TODO Auto-generated method stub
    LinkedList<String> lt=new LinkedList<String>();
    lt.add("String");
    lt.add("interstring");
    Oo oo=new Oo("不好玩","找工作好累");
    lt.add(oo.getIi());
    lt.add(oo.getMm());
    for(int i=0;i<lt.size();i++) {
        System.out.println(lt.get(i));
    }

}

泛型是什么?格式是?好处是?

泛型是一种特殊的类型，它把指定类型的工作推迟到客户端代码声明并实例化类或方法的时候进行。
也被称作为参数化类型，可以把类型当作参数一样传递过来，在传递过来之前并不明确，但在使用的时候就变得明确。
格式：

泛型类
public class 类名<泛型类型,……>
泛型方法
public<泛型类型>返回类型方法名(泛型类型)
泛型接口
public interface 接口名<泛型类型1……>

好处：

提高了程序的安全性
将运行期遇到的问题转移到了编译期
省去了类型强转的麻烦

增强for的格式是?好处是?弊端是?

作用：简化数组和Collection集合的遍历
格式:
for(元素类型变量变量:数组或者Collection集合){
使用变量即可，该变量就是元素
}
好处：简化遍历
弊端：增强for的目标要判断是否为null

静态导入的格式是?注意事项是?

格式：improt static 包名……类名.方法名;
注意事项:
方法必须是静态
如果有多个同名的静态方法，必须加前缀

可变参数的作用是?格式是?注意事项是?

作用：
定义方法时候不知道该定义多少个参数
格式：
修饰符返回值类型方法名(数据类型…… 变量名){}
注意事项：
这里的变量其实是一个数组。
如果一个方法有可变参数，并且有多个参数，那么可变参数肯定是最后一个

用下列集合完成代码

Collection
List
ArrayList
Vector
LinkedList

存储字符串并遍历
存储自定义对象并遍历

要求加入泛型，并有增强for遍历。
public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList<String> lt=new LinkedList<String>();
        Collection<String> l1=new ArrayList<String>();
        ArrayList<String> l2=new ArrayList<String>();
        Vector<String> l3=new Vector<String>();
        lt.add("String");
        lt.add("interstring");
        Oo oo=new Oo("不好玩","找工作好累");
        lt.add(oo.getIi());
        lt.add(oo.getMm());
        for(String s:lt) {
            System.out.println("LinkedList:"+s);
        }
        l1.addAll(lt);
        for(String s:l1) {
            System.out.println("Collection:"+s);
        }
        l2.addAll(l1);
        for(String s:l2) {
            System.out.println("ArrayList:"+s);
        }
        l3.addAll(l2);
        for(String s:l3) {
            System.out.println("LinkedLis:"+s);
        }
        
    }   
class Oo{
    public Oo(String ii, String mm) {
        super();
        this.ii = ii;
        this.mm = mm;
    }
    public String getIi() {
        return ii;
    }
    public void setIi(String ii) {
        this.ii = ii;
    }
    public String getMm() {
        return mm;
    }
    public void setMm(String mm) {
        this.mm = mm;
    }
    private String ii;
    private String mm;
}

Set接口

一个不包含重复元素的collection

HasSet类

不保证set的迭代顺序，特别是它不保证该顺序恒久不变。
底层数据结构是哈希表，元素是链表的数组。哈希表依赖于哈希值存储。

LinkedHashSet类

元素有序唯一，由链表保证元素有序，由哈希表保证元素唯一。

TreeSet

使用元素的自然顺序对元素进行排序，或者根据创建set时提供的Comparator进行排序，
底层数据结构是红黑树

编写一个程序，获取10个1至20的随机数，要求随机数不能重复。

Random r=new Random();
        int h;
        TreeSet<Integer> tst=new TreeSet<Integer>();
        for(int i=0;tst.size()<10;i++) {
            h=r.nextInt(20);
                tst.add(h);//TreeSet不允许重复元素，所有不需要判断重复
        }
        for(Integer m:tst) {
            System.out.println(m);
        }

什么是异常

异常就是Java程序在运行过程中出现的错误

异常的分类

异常分为三类

Error //编译时异常，运行时候可以不显示处理
Exception //编译时异常
RuntimeExeption //所有RuntimeExeption都成为运行时异常，必须显示处理

如何处理异常

JVM默认把异常的名称，错误原因以及一场出现的位置等信息输出在控制台
程序停止运行
异常的进行过程：
列如：jvm发现运算是已经违反了数学运算规则,java将这种常见的问题进行描述,并封装成了对象叫做ArithmeticException
当除0运算发生后,jvm将该问题打包成了一个异常对象.
并将对象抛给调用者main函数,new ArithmeticException("/by zero");

main函数收到这个问题时,有两种处理方式:
1,自己将该问题处理,然后继续运行
2,自己没有针对的处理方式,只有交给调用main的jvm来处理
jvm有一个默认的异常处理机制,就将该异常进行处理.并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上
同时将程序停止运行
异常处理方案

try……catch……finally
其中try用于检测异常，catch用于捕获异常，finally使用结束资源
throw、throws、Throwable

throw	throws	Throwable
只用在方法体内	用在方法声明后面，跟的是异常类名	它是接口
只能抛出一个异常对象名	可以跟多个异常类名	getMessage()获取异常信息，返回字符串
抛出异常由方法体内的语句处理	抛出异常由方法调用者来处理	printStackTrace()获取异常类名和异常信息，以及异常位置，返回void
执行throw则一定抛出了某种异常	throws表示出现异常的一种可能性，不一定发生	printStackTrace(PrintStram s)通常保存在文档中

当异常发生时候，后续程序需要执行就用try，不需要就用throws

编译时期异常和运行时期异常的区别

编译时期异常，JAVA程序必须显示处理，否则程序会发生错误。
运行时期异常，JAVA程序无需显示处理，也可以和编译时期异常一样处理。

finally关键字的特点

被finally控制的语句体一定会执行
特殊情况：在执行到finally之前jvm退出了。

作用：用于释放资源，在IO流操作和数据库操作中会见到

finally相关的面试题

final,finally和finalize的区别
final用于修饰类和变量，修饰过的类不能被继承，修饰过的变量就变成个常量
finally是异常处理中使用的。用于不管初步出现异常都必须处理的事情，列如关闭连接。
finalize是方法名，是JAVA的垃圾清理机制，用于清理对象内存，在垃圾收集器删除对象之前调用。

如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。
会执行，在return之前

File的构造方法

Public File(String pathname)
Public File(String parent,String child)
Public File(File parent,String child)

File的成员方法

创建功能
public boolean createNewFile()
public boolean mkdir()
public boolean mkdirs()
删除功能
public boolean delete()
重命名功能
public boolean renameTo(File dest)
判断功能
public boolean isDirectory()
public boolean isFile()
public boolean exists()
public boolean canRead()
public boolean canWrite()
public boolean isHidden()
基本获取功能
public String getAbsolutePath()
public String getPath()
public String getName()
public long length()
public long lastModified()
高级获取功能
public String[] list()
public File[] listFiles()

获取指定目录下指定后缀名的文件名称

判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
File file=new File("E:\\");
        String[] arr=file.list();
        for(String s:arr) {
            if(s.endsWith(".jpg")) {
                System.out.println(s);
            }
        }