io集合补充

  最近有点忙，很久没更新了，今晚准备肝一下，把集合，泛型，IO，异常再过一遍，写通博客记录一下。以后一定按时写博客///；

   一.Java的io

关于io的类，输入bf和sc都可以，sc更方便。输出write和printf也都可以。

注意：使用read时main函数要进行throws IOException

public class text {
    public static void main(String[] args) throws IOException {
        Scanner sc=new Scanner(System.in);
        BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
        char a=(char)bf.read();//read() 返回值是int，需要转换
        String s=bf.readLine();//readline（） 是用于String
        int x=sc.nextInt();
        System.out.write(1);
        System.out.write('A');//write(int x);
    }
}

 下面了解下Java的文件输入输出流

  FileInputStream 的方法：

 

  FileOutputStream的方法：

 IO中的目录：

  

 目录中的文件与文件夹读取：

 

 目录的删除：

 Java 流(Stream)、文件(File)和IO | 菜鸟教程 (runoob.com)

二. Java的集合

菜鸟教程集合

 集合的框架：

1.父接口：Collection（不唯一，无序） ，Map（键值对）

   子接口：List（类似数组，有插入顺序且不唯一），Set（唯一，无序）

2.实现类：LinkedList，ArrayList，HashSet，HashMap等

3.迭代器：Iterator（遍历）

注意：任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。

勤看以下集合的API(****

 一.ArrayList:

 菜鸟教程Arraylist

 ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们   可以添加或删除元素。

ArrayList<E> objectName =new ArrayList<>();　 // 初始化 

  注意E中必须为包装类，不能为基本数据类型。（BigInteger、BigDecimal 用于高精度的运算，且无对应的基本数据类型）

  增(add)   【区分c++的push_back(),python的append()】

  删(remove) 改(set) 查(get)

  如下text：

public class text {
    public static void main(String[] args) throws IOException {
        ArrayList<Integer> list =new ArrayList<Integer>();
        list.add(1);
        list.add(2); //增
        System.out.println(list.get(0));//查
        int x=list.get(0).intValue();//拆包
        System.out.println(x);
        list.set(1,9);//改
        System.out.println(list.get(1));
        list.remove(0);//删
        System.out.println(list.get(0));
        list.add(1000);
        list.add(100);
        System.out.println(list);//可以直接打印list
        for(int i=0;i<list.size();i++){
            System.out.printf("%d ",list.get(i));//遍历方法1
        }
        System.out.println("\n~~~");
        for(var i:list){
            System.out.print(i+" ");//遍历方法2
        }
        System.out.println("\n~~~");
        Collections.sort(list);//调用父接口的排序方法sort
        for(var i:list){
            System.out.print(i+" ");
        }
    }
}

 二.LinkedList：

  菜鸟教程LinkedList

  链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

  类似c++的链表，可以头尾增删，增删效率高；

  增删改查不变

  见如下：

public class text {
    public static void main(String[] args) throws IOException {
        LinkedList<Integer> list=new LinkedList<Integer>();
        list.add(5);
        list.add(2);
        list.add(0);
        list.addFirst(11);//增
        list.addLast(0);
        System.out.println(list);
        list.removeFirst();//删
        list.removeLast();
        System.out.println(list);
    }
}

 三.HashSet

  菜鸟教程HashSet

  HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。 

  注意新方法contains判断是否存在元素 返回布尔值

  如下：

public class text {
    public static void main(String[] args) throws IOException {
        HashSet<Integer> set=new HashSet<Integer>();
        set.add(1);
        set.add(0);
        System.out.print(set+"\n");
        System.out.print(set.contains(1)+"><"+set.contains(-1)+"\n");//判断是否存在元素
        set.add(0);
        System.out.print(set);
    }
}

 四.HashMap

  菜鸟教程HashMap

   HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

   增(put)  查( get(key) ) 删( remove(key) )

   如下： 

public class text {
    public static void main(String[] args) throws IOException {
        HashMap<Integer,String> map=new HashMap<>();
        map.put(5," love ");
        map.put(10," u ");
        map.put(1," I ");//增
        System.out.print(map+" \n");
        System.out.print(map.get(10)+"\n");//查
        map.remove(1);//删
        System.out.print(map+"\n");
        for(int i:map.keySet()){
            System.out.print(i+" ");
        }
        System.out.print("\nwo hui yi zi ai ni\n");
        for(String i:map.values()){
            System.out.print(i+" ");
        }
    }
}

 五.Iterator

   菜鸟教程Iterator

   注意Java中iterator不是指针，注意声明方式

   三个方法：next()，hasNext()，remove()；

public class text {
    public static void main(String[] args)  {
        ArrayList<Integer> list=new ArrayList<>();
        list.add(0);
        list.add(1);
        list.add(2);
        Iterator<Integer> it=list.iterator();
        Integer a=it.next();
        System.out.print(a+"\n");
        while(it.hasNext()){
            Integer b=it.next();
            if(b==0) {
                it.remove();
            }
            else {
                System.out.print(b+" ");
            }
        }
    }
}

 六.Object

  菜鸟教程Object

三.Java的泛型

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

 一.泛型方法

  

 test1：

public class text {
    public static <E> void printE(E[] arrys){//<E> 必须在返回类型前声明
        for(E i: arrys){
            System.out.print(i+" ");//用E代替数据类型
        }
        System.out.print("\n");
    }
    public static void main(String[] args)  {
        Integer[] integers={1,2,3,4};
        Character[] characters={'a','b','c','d'};
        String[] strings={"AA","BB","CC","DD"};
        printE(integers);
        printE(characters);
        printE(strings);
    }
}

  test2：

 可以限定泛型的数据类型范围，要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。

 二.泛型类

 泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

public class text<T> {
    T t;

    public void setT(T t) {
        this.t = t;
    }
    public T getT(){
        return t;
    }
}

类型通配符:

类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类。

public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));//不是泛型方法，只是参数为泛型，因为需要list
   }
}

 GG。。。