集合与异常、File

打工人上人

已于 2022-03-19 17:12:57 修改

阅读量454

点赞数

分类专栏： java 文章标签： java

于 2022-03-18 21:57:30 首次发布

本文链接：https://blog.csdn.net/weixin_48320674/article/details/123583543

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

数组与集合的对比

相同点: 都可以用于来存数据都可以通过索引来获取数据

不同点: 数组的长度是不可变集合长度是可变的，数组可以存任意的数据类型集合只能存引用数据类型(自动装箱)

单列集合（Collection接口）

ArrayList（有序，可以重复，增强for遍历）

ArrayList常用方法

boolean add(E e) ==>用于向集合添加数据
boolean remove(Object o) ==>删除集合中元素
boolean contains(Object o) ==>判断集合中是否有此元素
void clear() ==>清除集合中的所有的元素
boolean isEmpty() ==>判断集合是否为空
int size() ==>用于来获取集合的长度

两个集合的操作

boolean addAll(Collection<? extends E> c)==>col1.addAll(col2)：（col2 追加到col1中，col2 数据不发改变）
boolean containsAll(Collection<?> c)==> col1.containsAll(col2)：col1中的数据是否完全包含 col2 中数据
boolean removeAll(Collection<?> c)==>col1.removeAll(col2)：col1去除col2中数据，col2数据不变

遍历方法
package collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add("zhangsan");
        list.add(1);
        list.add(1);
        list.add(null);
        //----------第一种遍历
        Object[] objects = list.toArray();
        for (int i = 0; i <objects.length ; i++) {
            System.out.println(objects[i]);
        }
        //----------第二种遍历  迭代器遍历
        Iterator<Object> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //----------第三种遍历  增强for
        for (Object o : list) {
            System.out.println(o);
        }
        //----------第四种遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-----------------");
        //ListIterator  是 Iterator 的一个子类   比Iterator功能更加全面  一般用于来遍历List集合
        //void add(E e)   ==>向迭代器中增加数据
        //boolean hasPrevious()  ==> 用于来判断是否有上一个元素
        //E previous()  ==>用于来获取上一个元素
        ListIterator<Object> iterator1 = list.listIterator();
        iterator1.next();
        iterator1.next();
        iterator1.next();
        iterator1.next();
        while (iterator1.hasPrevious()){
            System.out.println(iterator1.previous());
        }
    }
}
并发异常

产生并发异常的原因: 使用迭代器来进行遍历但是又使用集合来添加数据迭代器不不知道集合在添加数据所以出现并发

解决方法第一种

解决方法第二种

ArrayList 是以数组的方式来进行存储，在多线程是是不安全，数组方式存储的特点: 查询快增删慢

CopyOnWriteArrayList线程安全（JUC）

LinkedList

LinkedList 是以双向链表的方式来进行存储，链表的方式来进行存储，查询慢，增加删除块

特有方法

public void addFirst(E e) 向集合中头部增加删除
public void addLast(E e) 向集合的尾部添加数据
public E getFirst()     获取集合头部的数据
public E getLast()      获取集合尾部的数据
public E removeFirst() 删除集合头部的数据
public E removeLast()   删除集合尾部的信息

Vector （线程安全）

Vector 是线程安全的,ArrayList 是线程不安全的。
Vector在数据满时增长为原来的两倍，而 ArrayList在数据量达到容量的一半时,增长为原容量的1.5倍。

HashSet(无序，不可重复，set是没有索引不能使用普通的for循环)

package collection.list;

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

public class ArrayListTest {
    public static void main(String[] args) {
        HashSet<Object> list = new HashSet<>();
        list.add("zhangsan");
        list.add(1);
        list.add(1);
        list.add(null);
        //----------第一种遍历
        Object[] objects = list.toArray();
        for (int i = 0; i <objects.length ; i++) {
            System.out.println(objects[i]);
        }
        //----------第二种遍历  迭代器遍历
        Iterator<Object> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //----------第三种遍历  增强for
        for (Object o : list) {
            System.out.println(o);
        }
        
    }
}

LinkedHashSet （有序，不可以重复）

多列集合

HashMap

map的常用方法

V put(K key,V value) 向map集合中以键值对来存数据也可以修改
void clear() ==> 将map集合进行清空
boolean isEmpty() ==>判断map集合中是否存在元素
V get(Object key) ==> 根据键来获取值
V remove(Object key) 根据键来删除
boolean containsKey(Object key) 判断键是否存在
boolean containsValue(Object value) 判断值是否存在
int size() 获取集合的长度
Set<K> keySet() 获取map中所有的键
Collection<V> values() 获取所有的值
Set<Map.Entry<K,V>> entrySet() ==> 用于来遍历map集合

遍历
package collection.map;

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

public class MapTest {
    public static void main(String[] args) {
        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put(1,"张三");
        hashMap.put(2,"李四");
        hashMap.put(3,"王五");
        //第一种遍历
        Set<Object> set = hashMap.keySet();
        for (Object o : set) {
            System.out.println(hashMap.get(o));
        }
        //第二种遍历
        Set<Map.Entry<Object, Object>> entries = hashMap.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            System.out.println(entry.getKey()+""+entry.getValue());
        }
        Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<Object, Object> next = iterator.next();
            System.out.println(next.getKey()+""+next.getValue());
        }
    }
}

HashMap与HashTable的区别？

HashMap没有考虑同步，是线程不安全的；Hashtable使用了synchronized关键字，是线程安全的；
HashMap允许K/V都为null；后者K/V都不允许为null；

ConcurrentHashMap和Hashtable的区别？

ConcurrentHashMap 结合了 HashMap 和 HashTable 二者的优势。HashMap 没有考虑同步，HashTable 考虑了同步的问题。但是 HashTable 在每次同步执行时都要锁住整个结构。 ConcurrentHashMap 锁的方式是稍微细粒度的。

集合的工具类（Collections）

(1)public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key) 使用二分法来进行查找必须是按照升序来进行排列第一个参数是需要查询的集合第二个参数是需要搜索的数据
(2)public static <T> void copy(List<? super T> dest,List<? extends T> src) 将所有元素从一个列表复制到另一个列表注意点：在进行copy方法使用的时候一定要给其长度
(3)public static <T> void fill(List<? super T> list,T obj) 使用指定元素替换指定列表中的所有元素
(4)public static int frequency(Collection<?> c,Object o)==>查找指定元素在集合出现的次数
(5)public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)最大值
   public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)最小值
   public static <T> boolean replaceAll(List<T> list,T oldVal,T newVal)替换
   public static void reverse(List<?> list)反转
   public static void shuffle(List<?> list) 随机置换集合中的元素
   public static <T extends Comparable<? super T>> void sort(List<T> list)排序

解决异常两种方式

声明异常: 也就是告诉调用者这段代码可能产生异常需要调用进行处理而方法的定义只是声明了，没有处理
捕获异常 ==> 自定对异常进行处理自己来解决这个异常==>捕获异常

捕获异常有三种写法

第一种 try catch
第二种 try catch finally
第三种 try finally

throw与throws的区别

throw 抛出异常对象 throws 声明异常类型
throw 定义在方法中 throws是定义再方法的参数的后面
throw 在方法中只能抛出一个异常对象 throws 可以声明多个异常类型
throw 声明的异常是实实在在存在 throws 不一定会发生不一定存在

自定义异常

自动以一个类继承 Throwable或者是Execption类
定义一个构造方法调用父类的构造给message进行赋值
package exception;

public class MyException extends Throwable {
    private String msg;

    public MyException(String message) {
        super(message);
    }
}
package exception;

public class ExceptionTest {
    public static void age(int age) throws MyException {
        if(age>10)
            throw new MyException("年龄不能大于10");
    }
    public static void main(String[] args) throws MyException {
//        age(11);
//        System.out.println("----------------");
        try {
            age(11);
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}
结果

File

构造方法

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

常用方法

public boolean createNewFile() 创建文件
public boolean mkdir() 创建一个空的文件夹不能创建父的目录
public boolean mkdirs() 创建的时候可以将父目录一起创建
public boolean delete()删除文件或者是删除空的文件夹（删除只能删除空的文件空的文件夹中不能包含文件以及文件夹）
----------------------------------
public boolean exists() ==>判断文件是否存在
public boolean isFile() ==>判断是否是一个文件
public boolean isDirectory() ==>判断是否是一个文件夹
public boolean isHidden() ==>判断是否是隐藏文件
----------------------------------
public String getAbsolutePath() ==>返回文件或者文件的绝对路径
public String getName() ==> 返回的是文件或者文件夹名称
public String getParent() ==> 返回的是文件或者文件夹的父目录
public String getPath() ==> 返回就是文件的构造方式中的地址
public long length() ==>返回的是文件的长度(文件所占的字节数)
public boolean renameTo(File dest) 重命名:在同一个目录下调用这个方法就是重命名剪切: 不在同一个目录下调用这个方法就是剪切
public String[] list() ==>返回是当前目录下所有的文件
public File[] listFiles(FileFilter filter) ==>使用过滤器来返回有效的文件
package file;

import java.io.File;
import java.io.IOException;

public class fileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/db/a.txt");
        System.out.println(file.exists());
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getName());
        System.out.println(file.getParent());
        System.out.println(file.getPath());
        System.out.println(file.length());
        File file1 = new File("D:");
        String[] list = file1.list();
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("---------------------");
        File[] listFiles = file1.listFiles();
        for (String s : list) {
            System.out.println(s);
        }
    }
}
结果