2021-05-18

RUIXUE423

于 2021-05-18 22:08:12 发布

阅读量147

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/m0_52759155/article/details/116999749

版权

笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

java学习笔记

集合与泛型
- Set：
- Map
泛型
- 泛型继承与通配符
- FILE
IO流

集合与泛型

package Collection;

import org.jetbrains.annotations.TestOnly;

import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Collection;

public class collection_test {
    @TestOnly
    public static void test(){
        Collection collection=new ArrayList();
        collection.add(123);
        collection.add("123");
        collection.add('a');
        System.out.println(collection.isEmpty());
        System.out.println(collection.size());
    }

package Collection;

import javafx.print.Collation;

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

/*
集合元素的遍历操作，使用迭代器Iterator
 */
public class InteratorTest {
    public static void test(){
        Collection collection=new ArrayList();
        collection.add(123);
        collection.add("456");
        collection.add(new String("SPRING"));
        Iterator iterator=collection.iterator();
         //遍历:
        /*方式一:System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());*/

        //抛异常
        //System.out.println(iterator.next());

        //方式二:
        while(iterator.hasNext())
            System.out.println(iterator.next());

    }
    public static void test1(){
        Collection collection=new ArrayList();
        collection.add(123);
        collection.add("456");
        collection.add(new String("SPRING"));
        collection.add(new String("SUMMER"));
        Iterator iterator=collection.iterator();
        while(iterator.hasNext()){
            Object obj=iterator.next();
            if("SPRING".equals(obj))
                iterator.remove();
        }
        Iterator iterator1=collection.iterator();
        while(iterator1.hasNext())
            System.out.println(iterator1.next());
    }
    public static void main(String[] args) {
        test();
        System.out.println("****************");
        test1();
    }
}

在这里插入图片描述

package Collection;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListTest {
    public static void test(){
        ArrayList list= new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add("ABCD");

        //void add(int index,OBject ele):在index位置插入ele元素
        list.add(1,"BB!");
        System.out.println(list);

        //boolean allALL(int index,Collection eles):从index位置开始将eles中的所有元素添加到新Arrlist中
        List list1= Arrays.asList(1,2,3);
        list.addAll(list1);
        System.out.println(list.size());//8
    }

    public static void main(String[] args) {
        test();
    }
}

在这里插入图片描述

Set：

在这里插入图片描述

package Collection;

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

public class SetTest {
    /*
    Set:存储无序的、不可重复的数据
        以HashSet为例说明：
        1。无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
        2。不可重复性：保证添加的元素按照equals（）判断时，不能返回true
     */
    public static void test()
    {
        Set set = new HashSet();
        set.add(123);
        set.add("AA");
        set.add("AA");
        set.add("BB");
        set.add("456789");
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    public static void main(String[] args) {
        test();
    }
}

在这里插入图片描述

Map

在这里插入图片描述

package MAP;

import java.util.*;

public class MapTest {
    public static void test(){
        Map map=new HashMap();
        map.put("AA",123);
        map.put("BB",246);
        map.put("CC",369);

        //遍历所有的key集：keySet()
        Set set=map.keySet();
        Iterator iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //遍历所有的value集:values()
        Collection values=map.values();
        Iterator iterator1 = values.iterator();
        for(Object obj:values) {
            System.out.println(obj);
        }

        //遍历所有的key-value
        Set entrySet = map.entrySet();
        Iterator iterator2=entrySet.iterator();
        while (iterator2.hasNext()){
            Object obj=iterator2.next();

            //entrySet集合中的元素都是entry
            Map.Entry entry=(Map.Entry)obj;
            System.out.println(entry.getKey()+"---->"+entry.getValue());

        }
    }

    public static void main(String[] args) {
        test();
    }
}

在这里插入图片描述

泛型

在这里插入图片描述

package Generic;


//自定义泛型结构:泛型类、泛型接口;泛型方法
public class GenericTest {
    //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
    //要求:如果定义了类是带泛型的，建议在实例化时要指明类的泛型
    public static void test(){
        Order<String> order=new Order<String>("orderAA",1001,"ord");
        System.out.println(order.getOrderT());
    }
    public static void test1(){
        SubOrder sub1=new SubOrder();

        //由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型类型
        sub1.getOrderT();
    }
    public static void main(String[] args) {
        test();
    }
}
class Order<T>{
    String orderName;
    int orderId;
    T orderT;
    public Order(){};
    public Order(String name,int orderId,T orderT){
        this.orderName=name;
        this.orderId=orderId;
        this.orderT=orderT;
    }
    public T getOrderT(){
        return orderT;
    }
}

class SubOrder extends Order<Integer>{
   // SubOrder不是泛型类
}
class SubOrder1<T> extends Order<T>{
//SubOrder1仍然是泛型类
}

在这里插入图片描述

package Generic;


import java.util.ArrayList;
import java.util.List;

//自定义泛型结构:泛型类、泛型接口;泛型方法
public class GenericTest {
    //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
    //要求:如果定义了类是带泛型的，建议在实例化时要指明类的泛型
    public static void test(){
        Order<String> order=new Order<String>("orderAA",1001,"ord");
        System.out.println(order.getOrderT());
    }
    public static void test1(){
        SubOrder sub1=new SubOrder();

        //由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型类型
        sub1.getOrderT();
    }
    public static void main(String[] args) {

    }

    public  void test2(){
        Order<String> order=new Order<>();
        Integer[] arr=new  Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);
    }
}
class Order<T>{
    String orderName;
    int orderId;
    T orderT;
    public Order(){};
    public Order(String name,int orderId,T orderT){
        this.orderName=name;
        this.orderId=orderId;
        this.orderT=orderT;
    }
    public T getOrderT(){
        return orderT;
    }
    //泛型方法:在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没有关系。
    //泛型方法，可以声明为静态的。原因:泛型参数是在调用方法时确定的。并非在实例化类时确定的
    public <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list=new ArrayList<>();
        for(E e:arr){
            list.add(e);
        }
        return list;
    }
}

class SubOrder extends Order<Integer>{
   // SubOrder不是泛型类
}
class SubOrder1<T> extends Order<T>{
//SubOrder1仍然是泛型类
}

泛型使用情景:

package Generic;

import java.util.List;

//DAO:date(base) access object
public class DAO<T> {

    //添加一条记录
    public  void add(T t){

    }
    //删除一条记录
    public boolean remove(int index){
        return false;
    }
    //修改一条记录
    public void update(int index,T t){

    }
    //查询一条记录
    public T getIndex(int index){
        return null;
    }
    //查询多条记录
    public List<T> getForList(int index){
        return null;
    }

    //泛型方法
    //举例:获取表中一共有多少条记录？获取最大的员工入职时间？
    public <E> E getValue(){
        return null;
    }
}
class Customer{

}
class CustomerDAO extends DAO<Customer>{

}

class DAOTest{
    public static void test(){
        CustomerDAO dao1=new CustomerDAO();
        dao1.add(new Customer());
        List<Customer> List = dao1.getForList(19);
    }
}

泛型继承与通配符

在这里插入图片描述

package Generic;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
1.泛型在继承方面的体现

2.通配符的使用

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210523164645554.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzUyNzU5MTU1,size_16,color_FFFFFF,t_70)

```java
package Generic;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
1.泛型在继承方面的体现

2.通配符的使用
 */
public class Test {
    /*
    1.泛型在继承方面的体现
        类A是类B的父类，但是G<A>和G<B>二者不具备子父类关系，二者是并列关系。

       补充:类A是类B的父类，A<G>是B<G>的父类
     */
    public static void test1(){
        Object obj=null;
        String str=null;

        obj=str;

        Object[] arr1=null;
        String[] arr2=null;
        arr1=arr2;

        List<Object> list1=null;
        List<String> list2=null;

        //此时的list1和list2的类型不具有子父类关系
        //编译不通过
        //list1=list2;
        /*
        反证法:
        假设list1=list2；
        list1.add(123);导致混入非Sting的数据，出错
         */
        show(list1);
    }
    public static void show(List<Object> list){

    }
    public static void test2(){
        List<String> list1=null;
        ArrayList<String> list2=null;
        list1=list2;
    }
    /*
    2.通配符的使用
        通配符:?

        类A是类B的父类，但是G<A>和G<B>二者是没有关系的，二者共同的父类是:G<?>。
     */
    public static void test3(){
        List<Object> list1=null;
        List<String> list2=null;

        List<?> list=null;

        list=list1;
        list=list2;
        print(list1);
        print(list2);

        List<String> list3=new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");

        list=list3;
        //添加:对于List<?>就不能向其内部添加数据。
        //除了添加null之外
        //list.add("DD");
       // list.add(?);
        list.add(null);

        //获取（读取）
        Object o = list.get(0);

    }
    public static void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
    /*
    3.有限制条件的通配符的使用
        ?extends A:
                    G<?extends A>可以作为G<A>和G<B>的父类，其中B是A的子类
        ?super B:
                 G<?super B>可以作为G<A>和G<B>的父类，其中B是A的父类
     */

    public static void test4(){

        //将extends看成≤
        //将super看成≥
        List<? extends Person> list1=null;
        List<? super Person> list2=null;

        List<Student> list3=null;
        List<Person> list4=null;
        List<Object> list5=null;

        list1=list3;
        list1=list4;
        list1=list5;

        list2=list3;
        list2=list4;
        list2=list5;
    }
}

FILE

在这里插入图片描述

IO流

在这里插入图片描述

package File;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderWriterTest {
    public static void test()  {
        /*
            将hello.txt文件内容读入程序中，并输出到控制台
            read():返回读入的一个字符。如果达到文件末尾，返回-1
            异常的处理:为了保证流资源一定可以执行关闭操作。需要使用try-catch-finlly处理
         */

        //1.实例化File类对象，指明要操作的文件
        try {
            File file=new File("C");

            //2.提供具体的流
            FileReader fr = new FileReader(file);

            //3.数据的读入过程
            //read():返回读入的一个字符。如果达到文件末尾，返回-1
            int read = fr.read();
            while(read!=-1) {
                System.out.println((char) read);
                read=fr.read();
            }

            //4.流的关闭操作:
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }
    }

    public static void main(String[] args) throws IOException {
            test();
    }

}

 //对read()操作升级:使用read的重载方法
    public static void test1(){
        FileReader fr= null;
        try {
            //1.File类的实例化
            File file=new File("");

            //2.FileReader流的实例化
            fr = new FileReader(file);
            //3.读入的操作
            //read(char[] cubf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            char[] cbuf=new char[5];
            int len;
            while((len=fr.read(cbuf))!=-1);
            {
                for(int i=0;i<len;i++)
                    System.out.println(cbuf[i]);
                //String str=new String();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr!=null)
         //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }


    }

write：

public static void testFileWriter() throws IOException{
        //1.提供File类的对象，指明写出的文件
        File file=new File("");

        //2.提供FileWrite的对象，用于数据的写出
        FileWriter fw=new FileWriter(file,true);

        //3.写出的操作
        fw.write("I hava a dream!\n");
        fw.write("You too!");

        //4.流资源的关闭
        fw.close();
    }

文件复制操作：

 public static void testFileReaderFileWriter(){
        FileReader fr= null;
        FileWriter fw= null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile =new File("");
            File destFile=new File("");

            //2.创建输入流和输出流对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            //3.数据的读入和写出操作
            char[] cubf=new char[5];
            int len;//记录每次读入到cbuf数组中字符的个数
            while((len=fr.read(cubf))!=-1){
                //每次写出len个字符
                fw.write(cubf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            if(fw!=null)
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if (fr!= null)
                        try {
                            fr.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                }

        }



    }

对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
对于非文本文件(.mp3,.avi,.jpg,.ppt,.doc)，使用字节流处理

package File;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileInputOutputStreamTest {
    public static void FileInputStreamtest() {
        FileInputStream fis = null;
        FileOutputStream fos=null;
        try {
            File srcfile=new File("");
            File destfile=new File("");


            fis = new FileInputStream(srcfile);
            fos=new FileOutputStream(destfile);
            byte[] buffer=new byte[5];
            int len;
            while((len=fis.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null)
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(fos!=null)
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    //指定路径下文件的复制
    public static void copyFile(String srcPath,String destPath){
        FileInputStream fis = null;
        FileOutputStream fos=null;
        try {
            File srcfile=new File(srcPath);
            File destfile=new File(destPath);


            fis = new FileInputStream(srcfile);
            fos=new FileOutputStream(destfile);
            byte[] buffer=new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null)
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(fos!=null)
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    public static void main(String[] args) throws IOException{
        long start=System.currentTimeMillis();
        String srcPath="";
        String destPath="";
        copyFile(srcPath,destPath);

        long end=System.currentTimeMillis();
        System.out.println("复制操作花费的时间为:"+(end-start));
    }

}

数据流

package File;

import java.io.*;

/*
    处理流之一:缓冲流的使用
    2.作用:提高流的读取，写入速度
        原因:内部提供了缓存区
	3.处理流,就是“套接”在已有的流的基础之上。
 */
public class BufferedTest {
    /*
        实现非文本文件的复制
     */
    public static void BufferedStreamtest(){
        BufferedInputStream bis= null;
        BufferedOutputStream bos= null;
        try {
            //1.造文件
            File srcFile=new File("C:\\Users\\Rui\\IdeaProjects\\demo\\src\\SaKuLa.jpg");
            File destFile=new File("C:\\Users\\Rui\\IdeaProjects\\demo\\src\\SaKuLa1.jpg");
            //2.造流
            //2.1造节点流
            FileInputStream fis=new FileInputStream(srcFile);
            FileOutputStream fos=new FileOutputStream(destFile);
            //2.2造缓存流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制细节:读取，写入
            byte[] buffer=new byte[10];
            int len;
            while((len=bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
               // bos.flush();//刷新缓冲区
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bos!=null)
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(bis!=null)
                    try {
                        bis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
            }

        }
        //4.关闭流
       //要求:先关闭外层的流，再关闭内层的流
      // bos.close();
        //bis.close();
        //说明:关闭外层流的同时，内层流也会自动进行关闭。关于内层流的关闭，我们可以省略

        //fos.close();
        //fis.close();


    }

    public static void main(String[] args)throws IOException {
        BufferedStreamtest();
    }
}

package File;

import java.io.*;

public class BufferedReaderBufferedWriterTest {
    public static void test() throws IOException{
        BufferedReader br=new BufferedReader(new FileReader(new File()));
        BufferedWriter bw=new BufferedWriter(new FileWriter(new File()));

        //读写操作
        //方式一:
        char[] cbuf=new char[1024];
        int len;
        while((len=br.read(cbuf))!=-1){
            bw.write(cbuf,0,len);
        }
        //方式二:
        String data;
        while((data=br.readLine())!=null){
            //方法一:
            //bw.write(data+"\n");
            //方法二:
            bw.write(data);
            bw.newLine();//提供换行操作
        }

        //关闭
        bw.close();
        br.close();
    }

    public static void main(String[] args)throws IOException {
        test();
    }
}

总结：
在这里插入图片描述

转化流：

package File;

import com.RX.Demo.JiChu.可变参数;

import javax.imageio.IIOException;
import java.io.*;

/*
       1.转化流:属于字符流
                InputStreamReader:将一个字节的输入流转换字符的输入流
                OutputStreamWriter:将一个字符的输出流转换为字节的输出流

       2.作用:提供字节流与字符流之间的转换

       3.解码:字节、字节数组----》字符数组、字符串
         编码:字符数组----》字节、字节数组

       4.字符集
 */
public class InputStreamReadertest{
    public static void test1()throws IOException {
        FileInputStream fis=new FileInputStream("C:\\Users\\Rui\\IdeaProjects\\demo\\src\\hello1.txt");
        //参数2指明了字符集,具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");

        char[] cubf=new char[1024];
        int len;
        while((len=isr.read(cubf))!=-1){
            String str=new String(cubf,0,len);
            System.out.print(str);
        }
        isr.close();
    }
    /*
        综合使用 InputStreamReader和OutputStreamWriter
     */
    public static void test2(){
        InputStreamReader isr= null;
        OutputStreamWriter osw= null;
        try {
            File file1=new File("src\\hello1.txt");
            File file2=new File("src\\hello1.txt");

            FileInputStream fis=new FileInputStream(file1);
            FileOutputStream fos=new FileOutputStream(file2);

            isr = new InputStreamReader(fis,"UTF-8");
            osw = new OutputStreamWriter(fos);

            char[] cbuf=new char[1024];
            int len;
            while((len=isr.read(cbuf))!=-1){
                osw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(isr!=null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(osw!=null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



    }
    public static void main(String[] args)throws IOException{
        test2();
    }
}

在这里插入图片描述

package File;

import java.io.*;

public class OtherStreamTest{
    public static void test() throws IOException {
        PrintStream ps=null;
        FileOutputStream fos=new FileOutputStream(new File("C:\\Users\\Rui\\IdeaProjects\\demo\\src\\hello2.txt"));
        ps=new PrintStream(fos,true);
        if(ps!=null){
            System.setOut(ps);
        }
        for(int i=0;i<=255;i++){
            System.out.print((char)i);
            if(i%50==0)
                System.out.print("\n");
        }
        ps.close();
        fos.close();
    }
    /*
    数据流
    1.DataInputStream和DataOutputStream
    2.作用:用于读取或写出基本数据类型的变量或字符串

    练习:将内存中的字符串、基本数据类型的变量写出到文件中。
     */
   public static void test1() throws IOException{
       DataOutputStream dos=new DataOutputStream(new FileOutputStream(new File("C:\\Users\\Rui\\IdeaProjects\\demo\\src\\hello.txt")));

       dos.writeUTF("xm");
       dos.flush();
       dos.writeInt(21);
       dos.flush();
       dos.writeBoolean(true);
       dos.flush();
       dos.close();
   }
   public static void test2() throws IOException{
       DataInputStream dis=new DataInputStream(new FileInputStream("C:\\Users\\Rui\\IdeaProjects\\demo\\src\\hello.txt"));

       System.out.println(dis.readUTF());
       byte[] bytes=new byte[5];
       System.out.println(dis.readInt());
   }
    public static void main(String[] args)throws IOException {
        test1();
        test2();
    }
}

在这里插入图片描述

RUIXUE423

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-05-18

package Collection;import org.jetbrains.annotations.TestOnly;import java.lang.annotation.Target;import java.util.ArrayList;import java.util.Collection;public class collection_test { @TestOnly public static void test(){ Collection co
复制链接

扫一扫