Java总结：包装类，栈与堆，集合Set，Map，List，迭代器，Collection工具类，IO操作

最新推荐文章于 2024-04-22 22:32:24 发布

无名一小卒

最新推荐文章于 2024-04-22 22:32:24 发布

阅读量297

点赞数 1

文章标签： Java学习

本文链接：https://blog.csdn.net/h1025372645/article/details/88827462

版权

Java基础专栏收录该内容

13 篇文章 3 订阅

订阅专栏

包装类

Java是一门面向对象的语言，一切皆对象，但是八大基本类型并不是对象

所以就有了包装类

基本类型     包装类
int         Integer
double      Double
float       Float
char        Character
byte        Byte
long        Long
short       Short
boolean     Boolean

这些包装类提供了一些方法，方便我们对数据进行想要的操作，下面以int类型为例

 public static void main(String[] args) {
        int x1 = Integer.parseInt("123");//将字符串转换为int类型
        float x2 = Float.parseFloat("11.11");//将字符串转换为float
        int x3 = Integer.MAX_VALUE;//获取Integer的最大值，Integer.MIN_VALUE，获取最小值
        
        Integer x4 = 55;  //自动执行装箱，拆箱操作，装箱将int-》Integer
        int x5 = x4;       //拆箱 将Integer-》int
        Integer x6 = 55;
        int x7 = x4.intValue()+x6.intValue();//Integer类型进行四则运算时可以通过intValue（）方                    
                                             //法获取int类型

    }

再存储数据时，八大基本类型与其他类型有着区别，八大基本类型在存储数据时，数据之间存放到了栈中，而其他对象在进行存储数据时，是在堆中建立一个空间，该空间存储数据，栈中则存放指向该数据的空间的地址

集合框架

集合代表了一组对象，类似与数组，但是数组的长度是固定的，集合的长度是可以改变的，集合长度改变的方式可以默认改变，也可以定义每次长度不够时增加的长度

集合框架只能存储对象

集合操作

集合的操作来讲主要就是“增删改查”，Collection接口提供方法

增：add，addAll

删：remove，removeAll

差：contains，containsAll

改：直接赋值，或者set

Map

键值对的形式存储数据，没有迭代器，其子类有HasMap与TreeMap，HasMap为无序的，TreeMap为有序的，简单案例如下

public static void main (String[] args){
         //HashMap 无序的
        Map<String, Integer> map = new HashMap<String, Integer>();
                                                //Map类是抽象的，不可以直接new，
                                                // 但是可以new继承与map类的子类
        map.put("test",1);//向map中添加元素
        map.put("test2",3);
        map.put("test1",2);
        map.size();//获取map中元素个数
        map.isEmpty();//判断map是否为空
        map.containsKey("s");//判断map中是否含有某个key
        map.remove("test");//根据key值对键值对进行删除
      //HasMap的循环
        for (Map.Entry<String,Integer> entry : map.entrySet()){
            System.out.println(entry.getKey()+":"+entry.getValue());//可以直接取出key与 
                                                                           //value
        }
        //Map没有继承迭代器，但是它自身也有foreach循环
        map.forEach((k,v)->{  //foreach循环，lambda表达式
            System.out.println(k+":"+v);
        });
        
        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+":"+integer);
            }
        });
        
        int value = map.get("test");//根据key获取对应的value
        Set<String> keySet= map.keySet();// 获取所有的key
        Collection<Integer> values = map.values();//获取所有的value
        for(Integer v : values){
            System.out.println(v); // 添加是顺序为 ：1 3 2 输出为：3 1 2
        }
        //TreeMap
        TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();
        treeMap.put(1,"一");
        treeMap.put(3,"三");
        treeMap.put(2,"二");
        Set<Integer> treeKeySet = treeMap.keySet();
        Collection<String> treeValue = treeMap.values();
        for(String va : treeValue){
            System.out.println(va); //TreeMap有序，根据key的值进行排序，key为字符串时则
                                    //根据ASC码排序
        }
}

List

有序集合，有序指添加的顺序是有序的，可以存储重复的元素

子类有Vector 向量，也就是动态数组，除了接口提供的方法，还额外提供set/get ，indexof，subList等操作

Stack 栈，后进先出

ArrAyList与LinkedList的区别：

    1.ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表结构。
    2.对于随机访问的get和set方法，ArrayList要优于LinkedList，因为LinkedList要移动指针。
    3.对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。
    出处：https://blog.csdn.net/qq_32679815/article/details/78907437

简单案例如下：

public static void main(Stringp[] args){
Vector<Integer> integers = new Vector<>();
        integers.capacity();//初始默认容量。10，容量不够时，会自动增长
        integers.size();//初始元素个数：0

        integers.add(0);//添加元素
        integers.add(1);
        integers.add(2);
        integers.add(5);
        integers.contains(3);//判断是否含有某个元素
        integers.indexOf(3);//获取对应下标元素的值
        integers.firstElement();//获取的第一个元素
        integers.get(3);//获取对应下标的元素的值
        integers.set(1,55);//修改对应元素下标的值

        //Stack 栈
        Stack<Integer> stack = new Stack<>();
        stack.push(5);//入栈
        stack.peek();//获取栈顶元素，不出栈
        stack.pop();//出栈
        stack.empty();//判栈空
        stack.search(6);//查找栈中是否有该元素

        //ArrayL
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(55);//添加元素
        arrayList.add(56);//添加元素
        arrayList.add(51);//添加元素
        arrayList.set(1,0);//修改对应下标元素的值
        arrayList.sort((o1,o2)->{
            if(o1 > o2)
                return 1; //1 降序，-1升序
            else
                return -1;
        });
        arrayList.remove(2);//移除对应下标的元素

        //LinkedList 方法的用法与ArrayList类似

        LinkedList<Integer> integers1=new LinkedList<>();
        integers1.add(5);//添加元素
        integers1.add(2);//添加元素
        integers1.add(9);//添加元素
        integers1.set(0,6);//修改元素的值
        integers1.indexOf(6);//获取对应元素的下标
        integers1.sort((o1,o2)->{  //排序
            if(o1>o2){
                return 1;
            }
            else
                return -1;
        });
        integers1.contains(6);//查找是否有该元素
}

Set 不会出现重复元素

简单案例

public static vodi main (String[] args){
        //HashSet 无序的
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("a");//添加元素
        hashSet.add("a");
        hashSet.contains("a");//查找元素
        hashSet.remove("a");//移除元素

        //TreeSet 有序的 操作与HasSet类似
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(5);
        treeSet.add(9);
        treeSet.add(3);
        treeSet.add(6);
        System.out.println(treeSet);//输出为升序
}

集合之间的关系

HashSet的底层HashMap

LinkedList的底层链表

ArrayList的底层数组

Iterable 迭代器

如果实现了Iterable，我们可以获取一个迭代器对象和使用foreach循环，案例如下

        TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();
        treeMap.put(1,"一");
        treeMap.put(3,"三");
        treeMap.put(2,"二");
        Set<Integer> treeKeySet = treeMap.keySet();
        Collection<String> treeValue = treeMap.values();
        for(String va : treeValue){
            System.out.println(va); 
        }

Collections 工具类

        Collections.max(treeSet);//获取最大值
        Collections.sort(arrayList);//排序
        Collections.shuffle(arrayList);//打乱顺序
        Collections.reverse(arrayList);//逆序

I/O操作

基本概念

应用程序和设备（键盘，屏幕，文件等）经常需要创建数据，java为了简化开发流程，将这种传输封装成流的概念，屏蔽硬件细节。

流有2种，字节流和字符流

字节流：就是把传输的数据看成没有特定含义的二进制数据

字符流：把数据看成字符

常用字符流相关的类

常用字节流相关的类

字节流

InputStream是表示输入字节流的所有类的超类是表示输入字节流的所有类的超类

OutputStream是表示字节输出流的所有类的超类。输出流接收输出字节并将其发送到某个接收器

序列化：将一个对象保存到外部存储器中，告诉别人怎么存储

反序列化:从一个外部存储器中读取一个对象。

简单案例：

 public static void main(String[] args) throws IOException {
        write();
        read();

        write1();
        read1();

    }

    //读
    public static void read() throws IOException {
        FileInputStream fis = new FileInputStream("F:/test1.txt");//从指定文件读取数据
        int ch;
        while (true){
            ch = fis.read();//读取数据
            if(ch == -1){ //当没有数据时，ch=-1
                break;
            }
            System.out.println(ch);//打印
        }
        fis.close();//关闭文件
    }

    //写
    public static void write() throws IOException{
        FileOutputStream fos = new FileOutputStream("F:/test1.txt");
        for(int i = 0;i<10;i++){
            fos.write(i);
        }
        fos.close();
    }

    //读 反序列化
    public static void read1() throws IOException {
        FileInputStream fis = new FileInputStream("F:/test11.txt");//从指定文件读取数据
        ObjectInputStream ois = new ObjectInputStream(fis);

        int x0 = ois.readInt();//序列化与反序列化的顺序要一直
        String str = ois.readUTF();
        int x1 = ois.readInt();
        System.out.println(x0+"----"+str+"----"+x1);
        ois.close(); //谁先开，谁最后关
        fis.close();//关闭文件
    }
    //写 序列化
    public static void write1() throws IOException{
        FileOutputStream fos = new FileOutputStream("F:/test11.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeInt( 124 );
        oos.writeUTF( "abc" );
        oos.writeInt( 44 );
        oos.close();
        fos.close();
    }

字符流

   public static void main(String[] args) throws IOException {
        write();
        read();
        write1();
        read1();
    }
    //写 序列化
    public static void write() throws IOException {

        FileWriter fw = new FileWriter("F:/test2.txt");
        fw.write(22);
        fw.write("abc");
        fw.close();
    }

    //读 反序列化
    public static void read() throws IOException{
        FileReader fr = new FileReader("F:/test2.txt");
        int read =fr.read();
        System.out.println(read);

        char[] str = new char[3];//字符串的底层数数组，在读取的时候，其实是一个个从数组中读取
        fr.read(str);
        System.out.println(Arrays.toString(str));
        fr.close();
    }

    //写 利用缓冲区
    public static void write1()throws IOException{
        FileWriter fw = new FileWriter( "F:/test22.txt" );
        //创建 写入 缓冲区
        BufferedWriter bufferedWriter = new BufferedWriter( fw );
        bufferedWriter.write( "abc" );
        bufferedWriter.newLine(); //新的一行
        bufferedWriter.write( 11 );
        bufferedWriter.flush(); //刷新缓冲区

        bufferedWriter.close();
        fw.close();
    }
    //读 利用缓冲区
    public static void read1()throws IOException{
        FileReader fr = new FileReader( "F:/test22.txt" );
        //创建 写入 缓冲区
        BufferedReader bufferedReader = new BufferedReader( fr );
        String s = bufferedReader.readLine();
        System.out.println(s);
        int x = bufferedReader.read();
        System.out.println(x);
        bufferedReader.close();
        fr.close();
    }

缓冲区

BufferedWriter

BufferedReader

超市购物，买很多很多零食，不是买一个去买一个单

提一个购物车，将零食全部放到购物车里头，一起结账，

这个购物车就是一个缓冲区

File

文件类，描述一个文件，我们用对象的方式描述一个文件

属性：名称、路径、大小、最后修改时间

方法：

创建文件、文件夹、重命名

判定是文件夹还是文件，

判定是否存在

public static void main(String[] args) {
        File file = new File("F:/music.mp3");
        System.out.println(file.getName());//获取文件名字
        System.out.println(file.length());//获取文件长度
        System.out.println(file.toString());//输出路径
        System.out.println(file.canRead());//能否读
        System.out.println(file.exists());//文件是否存在
        System.out.println(file.getPath());//获取路径
        
    }