Java-API、集合、IO

最新推荐文章于 2021-05-23 09:59:03 发布

AL ZN

最新推荐文章于 2021-05-23 09:59:03 发布

阅读量142

点赞数

文章标签： java api hashmap

本文链接：https://blog.csdn.net/weixin_45658089/article/details/115312193

版权

Java-API、集合、IO

学习参考资料来自博客园的：来自 https://www.cnblogs.com/fire-dong/p/13414699.html

学习资料：Java 菜鸟教程 – https://www.runoob.com/java/java-tutorial.html

1、常用API

1.1、Date

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。

第一个构造函数使用当前日期和时间来初始化对象，为 Date();
第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数，为 Date(long millisec)；

使用 SimpleDateFormat 格式化日期：

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");

这一行代码确立了转换的格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。

注意:有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。

解析字符串为时间

SimpleDateFormat 类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat 对象的格式化存储来解析字符串。

使用printf格式化日期

printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

转换符	说明	示例
c	包括全部日期和时间信息	星期六十月 27 14:21:20 CST 2007
F	"年-月-日"格式	2007-10-27
D	"月/日/年"格式	10/27/07
r	"HH:MM:SS PM"格式（12时制）	02:25:51 下午
T	"HH:MM:SS"格式（24时制）	14:28:16
R	"HH:MM"格式（24时制）	14:28

代码例子：

package com.AL.API;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest {
    public static void main(String[] args) throws ParseException {
        //System.exit(0);//强制退出java程序非0是异常结束
        long numsTime = System.currentTimeMillis();//返回当前时间与1970年子午夜交替毫秒值
        System.out.println("numsTime="+numsTime);
        System.out.println("###################################");
        
        Date date = new Date();//使用当前日期和事件去初始化对象
        System.out.println("此时日期为："+date);
        System.out.println(date.toString());
        System.out.println("###################################");
        
        DateFormat dateInstance = DateFormat.getDateInstance();//获取日期格式
        System.out.println(dateInstance);
        System.out.println("###################################");

        DateFormat dateTimeInstance = DateFormat.getDateTimeInstance();//获取具体日期时间
        String s = dateInstance.format(date);
        String s1 = dateTimeInstance.format(date);
        System.out.println(s);
        System.out.println(s1);
        System.out.println("###################################");
        
        String s2="2020/4/4 22:22:22";
        //编写对应日期格式，将字符串日期转换为日期格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        Date parse = simpleDateFormat.parse(s2);
        System.out.println(parse);
    }
}

结果为：

numsTime=1616939035805
###################################
此时日期为：Sun Mar 28 21:43:55 CST 2021
Sun Mar 28 21:43:55 CST 2021
###################################
java.text.SimpleDateFormat@3249f37
###################################
2021年3月28日
2021年3月28日 下午9:43:55
###################################
Sat Apr 04 22:22:22 CST 2020

例子：

package com.AL.API;

import java.util.Date;

public class DateTest02 {
    public static void main(String args[]) {
        // 初始化 Date 对象
        Date date = new Date();
        //c的使用
        System.out.printf("全部日期和时间信息：%tc%n",date);
        //f的使用
        System.out.printf("年-月-日格式：%tF%n",date);
        //d的使用
        System.out.printf("月/日/年格式：%tD%n",date);
        //r的使用
        System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);
        //t的使用
        System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);
        //R的使用
        System.out.printf("HH:MM格式（24时制）：%tR",date);
    }
}

结果为：

全部日期和时间信息：周日 3月 28 21:56:04 CST 2021
年-月-日格式：2021-03-28
月/日/年格式：03/28/21
HH:MM:SS PM格式（12时制）：09:56:04 下午
HH:MM:SS格式（24时制）：21:56:04
HH:MM格式（24时制）：21:56

1.2、Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

例子：

在下方的示例为简单的绝对值处理、开根号sqrt；比大小 max，min；四舍五入round；还有两种生成随机数的方式。

package com.AL.API;

import java.lang.reflect.Type;
import java.util.Random;

public class mathTest01 {
    public static void main(String[] args) {
        int abs = Math.abs(-5);
        Math.sqrt(1000.0);
        System.out.println("1000.0开根号的结果为："+ Math.sqrt(1000.0));
        System.out.println("100.0开根号的结果为："+ Math.sqrt(100.0));

        Math.max(1000,2000);
        System.out.println("你猜是1000大还是2000大？"+Math.max(1000,2000)+"大啊，傻子");
        Math.min(1000,2000);
        Math.round(1000.6f); //四舍五入
        System.out.println("1000.6f，你四舍五入是多少啊："+Math.round(1000.6f));

        Math.random(); //取随机数,生成区间为[0,1)的随机数
        System.out.println("来个随机数，老弟："+Math.random());

        Random random = new Random();
        int i = random.nextInt(100); //区间为0-bound的随机数
        System.out.println(i);
    }
}

结果为：

1000.0开根号的结果为：31.622776601683793
100.0开根号的结果为：10.0
你猜是1000大还是2000大？2000大啊，傻子
1000.6f，你四舍五入是多少啊：1001
来个随机数，老弟：0.08639066551206132
3

关于生成两种随机数的方法区别：

random()方法是产生区间[0,1)的double类型随机数。
在Random类中的 nextxxx方法是生成0-n 即指定区间的 xxx 类型的随机数
一般建议使用 (int) (Math.random()*n) 的方法经过类型转换取得到自己想要的随机数类型。

1.3、BigInteger类和BigDecimal类

BigInteger类和BigDecimal类是java中用于高精度、大数字运算的类。其中BigInteger类是用于整型的大数字，BigDecimal类用于大小数的类型的操作。这一部分参考博客地址为：https://blog.csdn.net/weixin_44234912/article/details/108928562

比如在处理银行等类似的业务时，那么你就需要 BigDecimal 类去进行处理，因为 float、double类型都只是一个近似的表示，只是无限接近于这种大小数。

1.3.1、BigInteger类能够支持任意精度的整数

在BigInteger类中，其中的参数是以字符串形式存在的数字。这个字符串为十进制的任意精度的整数。在java的基本类型中，long：占用8个字节。表示长整型：-9223372036854775808~9223372036854775807。

例子：查看BigInteger类是如何进行数值初始化，且是否能表示任意精度整数。以及BigInteger类关于基本的数学运算方法。

package com.AL.API;

import java.math.BigInteger;

public class BigDataTest01 {
    public static void main(String[] args) {
        BigInteger bigInteger = new BigInteger("999999999223372036854775807"); //这里面的参数为字符串型
        System.out.println(bigInteger);

        BigInteger bigInteger1 = new BigInteger("-999999999223372036854775807");
        System.out.println(bigInteger1);

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

        //对大数字进行基本的数学运算：
        System.out.println("加法的结果是："+bigInteger.add(bigInteger1));
        System.out.println("减法的结果是："+bigInteger.subtract(bigInteger1));
        System.out.println("乘法的结果是："+bigInteger.multiply(bigInteger1));
        System.out.println("除法的结果是："+bigInteger.divide(bigInteger1));
        System.out.println("取余的结果是："+bigInteger.remainder(bigInteger1));
        System.out.println(bigInteger.remainder(new BigInteger("4")));
    }
}

结果为：

999999999223372036854775807
-999999999223372036854775807
##############
加法的结果是：0
减法的结果是：1999999998446744073709551614
乘法的结果是：-999999998446744074312702607139099707396907784232501249
除法的结果是：-1
取余的结果是：0
3

1.3.2、BigDecimal类

BigDecimal类和 BigInteger类都能进行大数字的运算，不过BigDecimal类加入了对小数的处理。BigDecimal类支持任何精度的浮点数，可以用来计算银行业务这种的金融计算。

double：占用8个字节，4.9E-324~1.7976931348623157E308

BigDecimal 常用的构造方法如下。

BigDecimal(double val)：实例化时将双精度型转换为 BigDecimal 类型。
BigDecimal(String val)：实例化时将字符串形式转换为 BigDecimal 类型。

需要注意的是，当采用BigDecimal(double val) 的时候，是将 double类型的数据转换为 BigDecimal类型，所以此时的区间不能超过4.9E-324~1.7976931348623157E308。

例子：

package com.AL.API;

import java.math.BigDecimal;

public class BigDataTest02 {
    public static void main(String[] args) {
        BigDecimal bigDecimal = new BigDecimal("10.7976931348623157E308");
        System.out.println(bigDecimal);

        // 将双精度型的数 转换为 BigDecimal类型
        BigDecimal bigDecimal1 = new BigDecimal(1.7976931348623157E308);
        System.out.println(bigDecimal1);
    }
}

结果：

1.07976931348623157E+309
179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368

1.4、String类

Java 提供了 String 类来创建和操作字符串。使用一对引号 “” 来表示字符串。 String类有以下特点：

String声明为final的，不可被继承
String实现了Serializable接口：表示字符串是支持序列化的
实现了comparable接口：表示String可以比较大小
String内部定义了final char【】 value用于存储字符串数据
String：代表不可变的字符序列：简称：不可变性。体现：当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值通过字面量的方式给一个字符串赋值，此时的字符串值声明在字符串常量池中，字符串常量池中是不会存储相同内容的字符串。

例子：关于字符串的创建、连接。以及其它的String类中的方法：

public class stringTest {
    public static void main(String[] args) {
        //用构造函数创建字符串.  使用 new，即是在调用构造函数
        String string = new String("Faker");
        System.out.println(string);

        //直接创建字符串
        String s1= "hide in cool";
        //获取字符串长度
        System.out.println("hide in cool 的长度为:"+ s1.length());

        //连接字符串，可以使用  + ， 也可以使用contact方法
        System.out.println(string.concat(s1));

    }
}

结果：

Faker
hide in cool 的长度为:12
Fakerhide in cool

例子：基本类型和字符串类型的转换。

package com.AL.API;

public class stringTest02 {
    public static void main(String[] args) {
        //基本类型转换字符串
        Integer i=1;
        String s=i+"";
        String s1=Integer.toString(1);
        System.out.println(i.toString());
        System.out.println(s1+200);

        String s2=String.valueOf(i);
        System.out.println(s2);

        //字符串转换基本类型
        int i1=Integer.parseInt(s1);
        System.out.println(i1);
    }
}

结果：

其它的关于String类中的方法：

package com.AL.API;

public class stringTest03 {
    public static void main(String[] args) {
        //字符串的操作
        String s="IG 给我冲啊";
        //字符串检索
        //检索字符串是否有该字符，返回Boolean
        System.out.println(s.contains("IG"));//有返回true
        //检索字符串是否存在，存在返回位置下标，不存在返回-1
        System.out.println(s.indexOf(""));//存在返回位置下标
        //检索字符串开始位置是否为该字符
        System.out.println(s.startsWith("重"));//返回Boolean
        //检索字符串结尾位置是否为该字符
        System.out.println(s.endsWith("啊"));//返回Boolean

        //字符串替换
        System.out.println(s.replace("IG","lgd"));
        //字符串拆分以该字符拆分并输出0下标之间的的字符
        System.out.println(s.split("我")[0]);
        //字符的长度
        System.out.println(s.length());
        //字符是否为空
        System.out.println(s.isEmpty());
    }
}

结果：

true
0
false
true
lgd 给我冲啊
IG 给
7
false

2、集合

Java集合框架主要包括两种类型的容器：

集合（Collection），存储一个元素集合；
图（Map），存储键/值对映射。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

2.1、Java HashMap

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

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

HashMap 的 key 与 value 类型可以相同也可以不同。在HashMap 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。基本类型对应的包装类如下所示：

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

如果我们创建一个HashMap对象，其中key值类型为整型，value的类型为字符串。然后：

创建一个HashMap对象后，可以采用put() 方法添加键值对即 key-value；

查找元素，通过访问key值来获取对应的 value，使用 get(key) 方法；

删除元素，使用 remove(key) 方法来删除 key 对应的键值对(key-value)；

计算大小，长度，计算 HashMap 中的元素数量可以使用 size() 方法。

如下所示：

package com.AL.API;

import java.util.HashMap;

public class hashMapDemo01 {
    public static void main(String[] args) {
        //创建一个 HashMap 对象， 整型（Integer）的 key 和字符串（String）类型的 value
        HashMap<Integer, String> integerStringHashMap = new HashMap<>();
        //添加键值对. 添加键值对(key-value)可以使用 put() 方法
        integerStringHashMap.put(1,"AL ZN");
        integerStringHashMap.put(2,"al zn");
        integerStringHashMap.put(3,"大 雄");
        integerStringHashMap.put(4,"鑫 仔");
        System.out.println(integerStringHashMap);

        //使用get(key) 方法来获取 key 对应的 value
        System.out.println(integerStringHashMap.get(1));
        //使用 remove(key) 方法来删除 key 对应的键值对(key-value)
        integerStringHashMap.remove(4);
        System.out.println(integerStringHashMap);
        //计算 HashMap 中的元素数量可以使用 size() 方法
        System.out.println(integerStringHashMap.size());
    }
}

结果如下所示：

{1=AL ZN, 2=al zn, 3=大 雄, 4=鑫 仔}
AL ZN
{1=AL ZN, 2=al zn, 3=大 雄}
3

3、IO流

3.1、文件操作

package com.AL.IO;

import java.io.File;
import java.util.Arrays;

public class IODemo01 {
    public static void main(String[] args) {

        //创建一个文件
        //file.createNewFile();//创建一个文件，File写具体目录到创建的文件名
        File file =new File("E:\\Java_work\\Learning_code\\JavaSE\\IODemo01");
        file.mkdir();//创建一个目录
        System.out.println(file.exists());//判断是否存在
        System.out.println(file.isFile());//判断是否为一个文件
        System.out.println(file.isDirectory());//判断是否为一个目录
        System.out.println(Arrays.toString(file.list()));//获取目录里的文件名以数组方式打印
        
        // file.delete();//删除文件
        file.renameTo(new File("E:\\Java_work\\Learning_code\\JavaSE\\ioDemo01"));//改名字
    }
}

结果为：

true
false
true
[]

3.2、字节流

字节流中重要的两个流： FileInputStream 和 FileOutputStream。

FileInputStream.该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
FileOutputStream. 该类用来创建一个文件并向文件中写数据。如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

package com.AL.IO;

import java.io.*;

public class IODemo03 {
    public static void main(String[] args) {
        //创建一个并向文件中写数据
        try {
            byte bWrite[] = { 'H', 'e', 'l', 'l', 'o' };
            //创建一个并向文件中写数据
            OutputStream file2 = new FileOutputStream("E:/Java_work/Learning_code/JavaSE/IODemo02/hello.txt");
            for (int x = 0; x < bWrite.length; x++) {
                file2.write(bWrite[x]); // writes the bytes
            }
            file2.close();

            //读取文件中的数据
            InputStream fis = new FileInputStream("E:/Java_work/Learning_code/JavaSE/IODemo02/hello.txt");
            int size = fis.available();

            for (int i = 0; i < size; i++) {
                System.out.print((char) fis.read() + "  ");
            }
            fis.close();
        } catch (IOException e) {
            System.out.print("Exception");
        }
    }
}

结果：

H  e  l  l  o

3.2、字符流

FileWriter字符流。向对象中写入数据。默认写入是覆盖写入；有true为追加写入。

FileReader类似，不过是从对象中读取数据。

package com.AL.IO;

import java.io.FileWriter;
import java.io.IOException;

//字符流
public class IODemo04 {
    
    public static void main(String[] args) throws IOException {
        String s="你好！世界";
        FileWriter fw=null;
        try {
            //FileWriter字符流
            // 默认写入是覆盖写入；有true为追加写入
            fw=new FileWriter("E:/Java_work/Learning_code/JavaSE/IODemo02/hello.txt",true);
            fw.write(s);
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            fw.close();
        }
    }
}

结果：

Hello你好！世界

创建的文件进行写入时，可能会存在乱码，那么我们在设置参数时，可以指定编码为 UTF-8。

例子：在下面的例子中，创建一个文件对象，并向其中写入字符。在这里采用的默认写入，就是覆盖写入。

package com.AL.IO;

import java.io.*;

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

            File f = new File("E:\\Java_work\\Learning_code\\JavaSE\\IODemo02\\hello.txt");
            FileOutputStream fop = new FileOutputStream(f);
            // 构建FileOutputStream对象,文件不存在会自动新建

            OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
            // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk

            writer.append("中文输入");
            // 写入到缓冲区

            writer.append("\r\n");
            // 换行

            writer.append("English");
            // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入

            writer.close();
            // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉

            fop.close();
            // 关闭输出流,释放系统资源

            FileInputStream fip = new FileInputStream(f);
            // 构建FileInputStream对象

            InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
            // 构建InputStreamReader对象,编码与写入相同

            StringBuffer sb = new StringBuffer();
            while (reader.ready()) {
                sb.append((char) reader.read());
                // 转成char加到StringBuffer对象中
            }
            System.out.println(sb.toString());
            reader.close();
            // 关闭读取流

            fip.close();
            // 关闭输入流,释放系统资源
        }
}

结果：打开文档，发现原来的数据已经被完全覆盖

中文输入
English

AL ZN

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-API、集合、IO

Java-API、集合、IO学习参考资料来自博客园的：来自 https://www.cnblogs.com/fire-dong/p/13414699.html学习资料：Java 菜鸟教程 – https://www.runoob.com/java/java-tutorial.html1、常用API1.1、Datejava.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。第一个构造函数使用当前日期和时间来初始化对象，为 Date(
复制链接

扫一扫