day06_常用api

最新推荐文章于 2024-07-11 19:45:38 发布

robot_Jiang

最新推荐文章于 2024-07-11 19:45:38 发布

阅读量639

点赞数 11

文章标签： python 开发语言

本文链接：https://blog.csdn.net/barry_jiang/article/details/137107919

版权

所谓面向对象的编程，就是创建一个别人写好类的对象，然后调用人家写好的程序，来实现自己的需求

别人写好的程序还有一个高大上的名字：API(全称是Application Program Interface 应用程序接口)

1.包

什么是包？所谓的包就是一个文件夹而已，因为java中的类有很多，所以分了文件夹来管理，跑到java中获得了一个新的名字，叫做包

比如我们之前用的Scanner，Random就是java.util下的

在自己的程序中，调用其他包中的程序，需要注意下面一个问题

如果当前程序中，要调用自己所在包下的其他程序，可以直接调用。（同一个包下的类，互相可以直接调用）
如果当前程序中，要调用其他包下的程序，则必须在当前程序中导包, 才可以访问！
导包格式：import 包名.类名
如果当前程序中，要调用Java.lang包下的程序，不需要我们导包的，可以直接使用。
如果当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，此时默认只能导入一个程序，另一个程序必须带包名访问。

2.String类

是java.lang包下的，告诉你一个秘密，java.lang包下的类创建对象不需要导包，不要问为什么，问就是够浪。

如何创建一个String对象

方法一：直接定义

String s1 = "abc"; String s2 = "多易教育";

方法二：调用构造器创建对象

// 1、new String创建字符串对象，并调用构造器初始化字符串
String rs1 = new String();
System.out.println(rs1); // 默认就是一个空串 ""

String rs2 = new String("doit");
System.out.println(rs2);//doit

char[] chars = {'d', 'o', 'i','t'};
String rs3 = new String(chars);
System.out.println(rs3);//doit

byte[] bytes = {97, 98, 99};
String rs4 = new String(bytes);
System.out.println(rs4);//abc

String类的常用方法

一大堆方法，记是记不住的，用着用着就会了，不用记，谁记我打谁！！！

代码示例：

public class StringDemo2 {
    public static void main(String[] args) {
        String s = "doit";
        // 1、获取字符串的长度
        System.out.println(s.length());//4

        // 2、提取字符串中某个索引位置处的字符
        char c = s.charAt(1);
        System.out.println(c);

        // 字符串的遍历
        for (int i = 0; i < s.length(); i++) {
            // i = 0 1 2 3 4 5
            char ch = s.charAt(i);
            System.out.println(ch);
        }

        System.out.println("-------------------");


        // 3、把字符串转换成字符数组，再进行遍历
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        // 4、判断字符串内容，内容一样就返回true
        String s1 = new String("doit");
        String s2 = new String("doit");
        System.out.println(s1 == s2); // false
        System.out.println(s1.equals(s2)); // true


        // 5、忽略大小写比较字符串内容
        String c1 = "34AeFG";
        String c2 = "34aEfg";
        System.out.println(c1.equals(c2)); // false
        System.out.println(c1.equalsIgnoreCase(c2)); // true


        // 6、截取字符串内容 (包前不包后的)
        String s3 = "学大数据，来多易教育";
        String rs = s3.substring(0, 4);
        System.out.println(rs);

        // 7、从当前索引位置一直截取到字符串的末尾
        String rs2 = s3.substring(5);
        System.out.println(rs2);

        // 8、把字符串中的某个内容替换成新内容，并返回新的字符串对象给我们
        String info = "这个电影简直是个垃圾，垃圾电影！！";
        String rs3 = info.replace("垃圾", "**");
        System.out.println(rs3);

        // 9、判断字符串中是否包含某个关键字
        String info2 = "Java是最好的编程语言之一，我爱Java,Java不爱我！";
        System.out.println(info2.contains("Java"));
        System.out.println(info2.contains("java"));
        System.out.println(info2.contains("Java2"));

        // 10、判断字符串是否以某个字符串开头。
        String rs4 = "张三丰";
        System.out.println(rs4.startsWith("张"));
        System.out.println(rs4.startsWith("张三"));
        System.out.println(rs4.startsWith("张三2"));


        // 11、把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中返回给我们
        String rs5 = "张无忌,周芷若,殷素素,赵敏";
        String[] names = rs5.split(",");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}

3.ArrayList类

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

定义语法：

ArrayList<String> c = new ArrayList<>();
//<String> 这玩意儿叫泛型，指定的是往ArrayList中放什么类型的数据

ArrayList中常用的方法：

变量和类型	方法	描述
void	add(int index, E element)	将指定元素插入此列表中的指定位置。
boolean	add(E e)	将指定的元素追加到此列表的末尾。
void	clear()	从此列表中删除所有元素。
boolean	contains(Object o)	如果此列表包含指定的元素，则返回 true 。
E	get(int index)	返回此列表中指定位置的元素。
boolean	isEmpty()	如果此列表不包含任何元素，则返回 true 。
E	remove(int index)	删除此列表中指定位置的元素。
E	set(int index, E element)	用指定的元素替换此列表中指定位置的元素。
int	size()	返回此列表中的元素数。

代码示例：

package com.doit.doc;

import java.util.ArrayList;

public class ApisDemo {
    public static void main(String[] args) {
        //创建ArrayList的对象
        ArrayList<String> list = new ArrayList<>();

        //添加元素
        list.add("zss");
        list.add("lss");
        list.add("www");
        list.add("zll");
        list.add("tqq");
        System.out.println(list);//[zss, lss, www, zll, tqq]

        //根据索引获取元素
        System.out.println(list.get(0));//zss
        System.out.println(list.get(1));//lss
        System.out.println(list.get(2));//www
        System.out.println(list.get(3));//zll
        System.out.println(list.get(4));//tqq


        //删除集合中的元素
        list.remove(0);
        list.remove(0);
        list.remove(0);
        System.out.println(list);//[zll, tqq]

        //集合的长度
        System.out.println(list.size());//2

        //将0号索引的位置元素改成doit
        list.set(0,"doit");
        System.out.println(list);//[doit, tqq]

        //判断zss这个元素是否存在这个集合中
        boolean flag = list.contains("zss");
        System.out.println(flag);//false
        
        //判断这个集合是否为空集合(也就是集合中没有元素)
        boolean empty = list.isEmpty();
        System.out.println(empty);//false
        
        //清空集合的元素
        list.clear();
        System.out.println(list.size());//0

    }
}

4.hashSet类

他和ArrayList一样，存的是单个元素，但是底层不一样，咱们暂时不关心他的底层啦，后面会详细讲。

那为什么有了ArrayList还要学习HashSet呢？因为特点不一样，他会给我们的元素进去去重，顺序打乱

定义语法：

HashSet<String> set = new HashSet<>();

HashSet常用的方法：

变量和类型	方法	描述
boolean	add(E e)	如果指定的元素尚不存在，则将其添加到此集合中。
void	clear()	从该集中删除所有元素。
boolean	contains(Object o)	如果此set包含指定的元素，则返回 true 。
boolean	isEmpty()	如果此集合不包含任何元素，则返回 true 。
boolean	remove(Object o)	如果存在，则从该集合中移除指定的元素。
int	size()	返回此集合中的元素数（基数）。

代码示例：

package com.doit.doc;

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

public class ApisDemo2 {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();

        //往set集合中添加元素
        set.add("zss");
        set.add("lss");
        set.add("zss");
        set.add("lss");
        set.add("www");

        //虽然我们存了两个zss和两个lss进去，但是读出来的时候只有一个，内部给我们自动去重了
        //并且读出来的顺序和我们存进去时候的顺序也不一样，这就是乱序
        System.out.println(set);//[www, zss, lss]

        boolean flag = set.contains("zss");
        System.out.println(flag);//true

        //集合的长度
        System.out.println(set.size());//3

        //将zss这个元素移除
        set.remove("zss");
        System.out.println(set);//[www, lss]
        
        //清空集合
        set.clear();
        System.out.println(set.size());//0


    }
}

5.HashMap类

不管是数组也好，ArrayList，HashSet也好，都是存储的单个元素的集合，比如里面放的都是String类型的zss，lss，ww，zl等

但是我们怎么表示一对对的值呢？比如（name,zss），（age，18），（gender,male）这种结构的数据呢？对数据有一种自我的描述，看到zss，就知道他代表的是name，看到18就知道对应的是age，这种类型的数据我们可以用map集合来存储

注意哦，这种结构的数据就像一对对的夫妻一样，成群结队的出现的，你可不要无情的拆散他们。称他们为key-value结构的数据

定义语法：

HashMap<String, String> map = new HashMap<>();

//<String, String> 这是两个泛型，前面一个是key的类型，后面一个是value的类型，确定后就不能变了

HashMap中常用的方法：

变量和类型	方法	描述
void	clear()	从此映射中删除所有映射。
boolean	containsKey(Object key)	如果此映射包含指定键的映射，则返回 true 。
Set<Map.Entry<K,V>>	entrySet()	返回此映射中包含的映射的Set视图。
V	get(Object key)	返回指定键映射到的值，如果此映射不包含键的映射，则返回 null
boolean	isEmpty()	如果此映射不包含键 - 值映射，则返回 true 。
Set<K>	keySet()	返回此映射中包含的键的Set视图。
V	put(K key, V value)	将指定的值与此映射中的指定键相关联。
V	remove(Object key)	从此映射中删除指定键的映射（如果存在）。
int	size()	返回此映射中键 - 值映射的数量。

代码示例：

package com.doit.doc;

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

public class ApisDemo1 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();

        //往集合中放元素
        map.put("stu001","zss");
        map.put("stu002","lss");
        map.put("stu003","www");
        map.put("stu004","zll");
        map.put("stu005","tqq");

        System.out.println(map);//{stu005=tqq, stu004=zll, stu001=zss, stu003=www, stu002=lss}

        //根据key获取对应value的值
        //站在上帝视角，001确实存在。返回zss
        String stu001 = map.get("stu001");
        System.out.println(stu001);//zss

        //006不存在返回什么呢？null
        String stu006 = map.get("stu006");
        System.out.println(stu006);//null

        //思考，如果stu001有两个怎么办？？
        //不好意思，key只能有一个，如果有两个，后面一个会覆盖前面一个
        map.put("stu004","doit");
        String stu004 = map.get("stu004");
        System.out.println(stu004);//doit


        //判断key是否存在
        boolean flag = map.containsKey("stu004");
        System.out.println(flag);//true

        //将stu004这个key，value移除
        map.remove("stu004");


        //返回map集合的长度
        System.out.println(map.size());
        
        
        //map集合的遍历
        //方法一：
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"=>"+value);
        }

        //方法二
        Set<String> keys = map.keySet();
        for (String key : keys) {
            String value = map.get(key);
            System.out.println(key+"=>"+value);
        }


    }
}

6.File类

操作电脑上文件的类，可以创建，删除文件，文件夹，查看文件信息等

定义语法：

File file = new File("D:\\test");

//"D:\\test"   字符串类型的文件路径

File类的常用方法

变量和类型	方法	描述
boolean	delete()	删除此抽象路径名表示的文件或目录。
boolean	exists()	测试此抽象路径名表示的文件或目录是否存在。
String	getName()	返回此抽象路径名表示的文件或目录的名称。
String	getParent()	返回此抽象路径名父项的路径名字符串，如果此路径名未指定父目录，则返回 null 。
String	getPath()	将此抽象路径名转换为路径名字符串。
boolean	isDirectory()	测试此抽象路径名表示的文件是否为目录。
boolean	isFile()	测试此抽象路径名表示的文件是否为普通文件。
String[]	list()	返回一个字符串数组，用于命名此抽象路径名表示的目录中的文件和目录。
boolean	mkdir()	创建此抽象路径名指定的目录。

代码示例：

package com.doit.doc;

import java.io.File;

public class ApisDemo3 {
    public static void main(String[] args) {
        File file = new File("D:\\test");

        //查看这个路径是否存在
        boolean flag = file.exists();
        System.out.println(flag);

        //列出该文件下所有的文件和文件夹，以字符串的心事展示给我们
        String[] list = file.list();
        for (String s : list) {
            /*
            a.txt
            aaa
            b.txt
            bbb
            c.txt
             */
            System.out.println(s);
        }

        //展示文件的路径
        String path = file.getPath();
        System.out.println(path);//D:\test

        //判断一个文件是否是一个文件，或者是否是一个文件夹
        boolean directory = file.isDirectory();
        boolean file1 = file.isFile();
        System.out.println(directory);//true
        System.out.println(file1);//false


        //获取该文件或者文件夹的名字
        System.out.println(file.getName());//test

        //获取该文件或者文件夹的父文件名字 
        System.out.println(file.getParent());//D:\
        
        //指定的路径肯呢个不存在，让他给我们创建
        file.mkdir();


    }
}

7.IO流入门

根据数据的流向分为：输入流和输出流。

输入流 ：把数据从其他设备上读取到内存中的流。
输出流 ：把数据从内存 中写出到其他设备上的流。

根据数据的类型分为：字节流和字符流。

字节流 ：以字节为单位，读写数据的流。
字符流 ：以字符为单位，读写数据的流。

7.1字节流

定义语法：

File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);

//创建FileInputStream对象，本质上是调用他的构造方法，需要我们传入一个参数，类型是File
// 所以就new 一个File对象传进去

//字节输出流
File file = new File("a.txt");
FileOutputStreamfos = new FileOutputStream(file);

文件字节输入流中的方法

变量和类型	方法	描述
void	close()	关闭此文件输入流并释放与该流关联的所有系统资源。
int	read()	从此输入流中读取一个字节的数据。
int	read(byte[] b)	从此输入流 b.length最多 b.length字节的数据读 b.length字节数组。
int	read(byte[] b, int off, int len)	从此输入流 len最多 len字节的数据读入一个字节数组。
long	skip(long n)	跳过并从输入流中丢弃 n字节的数据。

代码示例：

package com.doit.doc;

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

public class ApisDemo4 {
    public static void main(String[] args) throws IOException {

        //文件中的内容：hello,doit
        FileInputStream fis = new FileInputStream(new File("D:\\test\\a.txt"));
        //每次读取一个字节
        int read = fis.read();
        System.out.println((char) read);//104    h    通过ascii表查到h就是104


        //一次读取一个字节，效率低
        int num = 0;
        while ((num = fis.read()) != -1){
            System.out.print((char) num);//hello,doit
        }


        //长度为1024的字节数组
        byte[] bytes = new byte[1024];
        int n = 0;
        while ((n = fis.read(bytes))!=-1){
            String s = new String(bytes, 0, n);
            System.out.println(s);
        }

        //跳过几个字节再去读
        long skip = fis.skip(5);
        int num1 = 0;
        while ((num1 = fis.read()) != -1){
            System.out.print((char) num1);//,doit
        }

        //关闭资源
        fis.close();

    }
}

文件字节输出流中的方法

变量和类型	方法	描述
void	close()	关闭此文件输出流并释放与此流关联的所有系统资源。
void	write(byte[] b)	将指定字节数组中的 b.length字节写入此文件输出流。
void	write(byte[] b, int off, int len)	将从偏移量 off开始的指定字节数组中的 len字节写入此文件输出流。
void	write(int b)	将指定的字节写入此文件输出流。

代码示例：

package com.doit.doc;

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

public class ApisDemo5 {
    public static void main(String[] args) throws IOException {

        FileOutputStream fos = new FileOutputStream(new File("D:\\test\\res.txt"));

        //往res.txt中写入一个a
        fos.write(97);

        // 字符串转换为字节数组
        byte[] b = "abcde".getBytes();
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);

        fos.close();


    }
}

7.2字符流

定义语法

File file = new File("D:\\test\\a.txt");
FileReader fr = new FileReader(file);


//传入一个文件对象或者字符串都可以
FileWriter fw = new FileWriter("fw.txt");
File file = new File("D:\\test\\a.txt");
FileWriter fw = new FileWriter(file);

字符输入流的方法

变量和类型	方法	描述
void	close()	关闭此文件输入流并释放与该流关联的所有系统资源。
int	read()	从此输入流中读取一个字符的数据。

代码示例：

package com.doit.doc;

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

public class ApisDemo6 {
    public static void main(String[] args) throws IOException {

        File file = new File("D:\\test\\a.txt");
        FileReader fr = new FileReader(file);

        // 定义变量，保存数据
        int b ;
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }


        int len ;
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }


        //关闭资源
        fr.close();


    }
}

字符输出流的方法

变量和类型	方法	描述
void	close()	关闭此文件输出流并释放与此流关联的所有系统资源。
void	write(char[] c)	将指定字节数组中的 b.length字节写入此文件输出流。
void	write(String str)	直接写入一个字符串
void	write(int b)	将指定的字节写入此文件输出流。

代码示例：

package com.doit.doc;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class ApisDemo7 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\test\\a.txt");
        FileWriter fw = new FileWriter(file);

        fw.write("学大数据，就来多易教育");

        char[] chars = "学大数据，就来多易教育".toCharArray();
        fw.write(chars);
        
        
        fw.write(97);
        fw.write('学');
        fw.write('大');
        fw.write('数');
        fw.write('据');
        fw.write('，');
        fw.write('来');
        fw.write('多');
        fw.write('易');
        
        fw.close();

    }
}

7.3缓冲流

定义语法

BufferedReader br = new BufferedReader(new FileReader("D:\\test\\a.txt"));

缓冲流中的方法

变量和类型	方法	描述
int	read()	读一个字符。
int	read(char[] cbuf, int off, int len)	将字符读入数组的一部分。
String	readLine()	读一行文字。
long	skip(long n)	跳过字符。

代码示例

package com.doit.doc;

import java.io.*;
import java.nio.Buffer;

public class ApisDemo8 {
    public static void main(String[] args) throws IOException {

        //创建字符缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("D:\\test\\a.txt"));

        //读取一行数据
        String line = br.readLine();
        System.out.println(line);

        //读取一个字符
        int read = br.read();
        System.out.println(read);

        
        br.close();



    }
}

robot_Jiang

关注

11
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
day06_常用api

String s2 = "多易教育";//<String> 这玩意儿叫泛型，指定的是往ArrayList中放什么类型的数据//<String, String> 这是两个泛型，前面一个是key的类型，后面一个是value的类型，确定后就不能变了//"D:\\test" 字符串类型的文件路径。
复制链接

扫一扫