Java API (0409)

包装类

装箱拆箱

// int -> Integer
int i = Integer.intValue();

// Integer -> int 
Integer integer = Integer.valueOf(i);
Integer integer = new Integer(i);

类型转换

Integer <-> String

// Integer -> String 
String str = i.toString;
// String -> Integer
Integer integer = Integer.parseInt(str);

String <-> byte[ ]

byte[] bs = s.getBytes();
String str = new String(bs);

String -> char[ ] / char

char[] cs = str.toCharArray();
char c = str.charAt(i); // 字符串的第i个转化为char

String <-> StringBuffer

StringBuffer sb = new StringBuffer(str);
String str = sb.toString();

Integer

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); //F,new 方法开辟不同的内存空间

// valueOf() 方法 -128 ~ 127 直接返回 数值 i
Integer m = 1;
Integer n = 1;
System.out.println(m == n); // T

// 如果不在-128~127,就返回 new Integer(i)
Integer x = 128;
Integer y = 128;
System.out.println(x == y);// F，调用new方法，地址不同

Character

判断

//判断是不是 数字
Character.isDigit('a');

//判断是不是 字母
Character.isLetter('6');

//判断是不是 大写
Character.isUpperCase('A');
//判断是不是 小写
Character.isLowerCase('a');

//判断是不是 空格
Character.isWhitespace(' ');

转化

//转成大写
Character.toUpperCase('a');
//转成小写
Character.toLowerCase('A');

String

保存字符串常量，不可修改

常用方法

String str = "ab c safafasfasfm";

// 按下标取值
str.charAt(3);

// 判断是否存在“sa”
str.contains("sa");

// 判断是否等于“abc”比较内容
str.equals("abc");

// 从头/尾差找“fas”，返回下标
str.indexOf("fas");
str.lastIndexOf("fas");

// 替换
str.replace("fas","abc");

// 分割，取返回数组元素的【1】
str.split("a")[1];

// 提取 [0,6) 下标的值
str.substring(0,6);

// 进制转换，八进制数转化二进制字符串
String s=Integer.toString(8, 2); 

// 如果常量池没有str，则创建str并返回这个字符串的地址
// 如果常量池存在str的引用，则返回str的引用
str.intern();

String Buffer

保存字符串变量，可以不改变引用地址的情况修改内容，存放堆中

与String相同的方法：charAt()，length()，indexOf()，lastIndexOf()

常用方法

StringBuffer sb = new StringBuffer("abc");

// 末尾追加
sb.append("666"); // abc666

// 在下标 i 插入 str
sb.insert(3,"999"); // abc999666

// 删除下标 [i,j) 的元素
sb.delete(2,6); // ab666

// 替换 [3,4) 的元素为 888
sb.replace(3,4,"888"); //abc68886

// 提取 [0,1) 下标的值
sb.subSequence(0,1);

// 反转
sb.reverse();

// StringBuffer 没有重写equals，因此比较的是地址【与String区分】
System.out.println(str.equals("abc"));

StringBuilder

方法与 StringBuffer 相同

区别

	String	StringBuffer	StringBuilder
字符序列	不可变	可变	可变
修改操作	效率低	效率较高	效率最高
线程		安全	不安全
适用	少量修改	多修改，多线程	多修改，单线程

File

创建

//创建新文件，路径不存在报错
public boolean createNewFile() 

//创建单层目录
public boolean mkdir()
    
//创建多级目录
public boolean mkdirs()

修改

//删除文件或空目录
public boolean delete()
    
// 重命名  
public boolean renameTo(File dest)

判断

//判断File对象是否表示的是一个文件
public boolean isFile()
    
//判断File对象是否表示的是一个目录
public boolean isDirectory()
    
//判断File对象是否存在
public boolean exists()

获取

//获取文件的绝对路径
public File getAbsolutePath()

//获取创建时的路径
public String getPath()

//获取目录名，文件名
public String getName()
    
//获取文件的字节大小
public long length()

//获取最后一次修改的时间
public long lastModified()
    
//获取当前目录的所有文件名
public String[] list()
    
//返回当前目录下的，文件和文件夹的绝对路径形式的File对象数组
public File[] listFiles()

自定义获取

//获取这个文件夹下，满足filter过滤器的条件的文件
//功能接口 FileFilter -> boolean accept(File pathname)
File[] listFiles(FileFilter filter) 
    
    
//留下所有txt文件
public class FileTest {
    public static void main(String[] args) {
        File file = new File("E:\\temp");
        //匿名内部类创建一个过滤器
        FileFilter fileFilter = new FileFilter() {
            @Override
            public boolean accept(File dir) {
                //条件是 dir对象是一个文件并且它的名字以txt结尾
                return dir.isFile() && dir.getName().endsWith("txt");
            }
        };
        // Lambada创建一个过滤器
        FileFilter fileFilter = 
            pathname -> pathname.isFile() && pathname.getPath().endsWith("txt");
        
        //在有过滤器的情况下创建一个File[]数组，并且遍历
        File[] files = file.listFiles(fileFilter);
        for(File f : files){
            System.out.println(f);
        }
    }

文件名排序

Arrays.sort(files, new Comparator<File>())

Date

Date date = new Date();

// 默认输出格式 Sat Apr 09 16:40:27 CST 2022
System.out.println(date);
//将日期转化为Long类型的数字（ms） （1970 00:00 -- 至今）
System.out.println(date.getTime()); 
// 获取系统时间戳（ms），long类型
System.out.println(System.currentTimeMillis());

// 日期自定义格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 2022-04-09 16:38:27
System.out.println(sdf.format(date));

// 将自定义格式的字符串转化为Date
Date date1 = sdf.parse("2022-04-09 16:38:27");

集合

Array

// 遍历
Arrays.toString(一维数组名);

ArrayList

import java.util.ArrayList;

ArrayList<Integer> arrayList = new ArrayList<Integer>();

student s1 = new student(123,"li");

// 增加
arrayList.add(s1);

// 删除
arrayList.remove(s1);

// 按下标获取元素
arrayList.get(1).print();

// 根据元素查询下标
System.out.println(arrayList.indexOf(s2));

// 判断arrayList中是否存在s1
System.out.println(arrayList.contains(s1));

// 替换
arrayList.set(0, s3);

// 打印存储元素数量
System.out.println(arrayList.size());

// 复制arrayList的元素到arrayList2的3号下标之后
ArrayList<student> arrayList2 = new ArrayList<student>();
arrayList2.addAll(3，arrayList);

// 反转 1，2，3 --> 3,2,1
Collections.reverse(arrayList);

// 交换集合下标1，2的元素
Collections.swap(arrayList, 1, 2);

// 集合元素下标+2；1，2，3 --> 2,3,1
Collections.rotate(arrayList, 2);

// 排序
Comparator<student> cs = new Comparator<student>(){
    @Override
    public int compare(student s1, student s2){
        if(s1.id>=s2.id)
            return 1;  
        else
            return -1;
    }
};
Collections.sort(arrayList,cs);

LinkList

//LinkedList是一个双向链表结构的list
LinkedList<student> linkList =new LinkedList<student>();
// 头插，尾插
linkList.addFirst(s3);
linkList.add(s2);

// 删头元素，尾元素，按下标删除
linkList.removeFirst();
linkList.removeLast();
linkList.remove(1);

// 打印获取的头元素，尾元素，按下标获取
linkList.getFirst().print();
linkList.getLast().print()
linkList.get(1).print();

// 替换
linkList.set(1, s3);

HashSet

// 无序，不可重复
HashSet<Integer> hs = new HashSet<Integer>();

// 插入
hs.add(666);

// 迭代器打印
Iterator<Integer> it = hs.iterator();
while(it.hasNext()) {
    System.out.print(it.next()+" ");
}

// 删除
hs.remove(22);

// 按元素查询
System.out.println(hs.contains(13));

HashMap

// 有序，键值对存储，键不能重复，值可以重复
HashMap<Integer,student> hm = new HashMap<Integer,student>();
// 增加
hm.put(i, "str");

// 删除
hm.remove(6);

// 按键，值查询
System.out.println(hm.containsKey(7));
System.out.println(hm.containsValue(s1));

// 按键获取
hm.get(3).print();

// 修改
hm.replace(9, s3);

Queue

//队列基于LinkedList 
Queue<student> qe = new LinkedList<student>();

// 入队--尾进
qe.offer(s1);

// 出队--头出
qe.poll();

// 查看队首元素，不出队
System.out.println(qe.peek());

工具类

Object

getClass() ：返回【Class对象】

通常用来判断引用类型是否相同

获取Class对象，这个对象是JVM在类加载时创建的，同类仅有一个

区分：运行时类的Class对象只有一个，而类的对象可以有无数个

toString()：返回【全限定类名@16进制地址值】

equals(Object obj) 判断对象地址是否相等，等价 ==

hashCode()：返回【十进制地址值】

clone()：一种创建对象的方式

重写clone 的类，要实现 cloneable 接口

与 new 的区别：clone 依赖 native 方法，不调用构造器创建

Reflection 反射

Properties

Properties properties = new Properties();
// 读取配置文件
properties.load(new FileInputStream("myDeno\\myDeno.properties"));
// 获取 properties 文件中 classfullpath 字段
String classFullPath = properties.get("classfullpath").toString();

Class

// 加载类，返回一个Class对象，classFullPath存储了一个 全限定类名 的字符串
Class aClass = Class.forName(classFullPath);
// 返回【全限定类名】
aClass.getName()
// 返回【类名】  
aClass.getSimpleName()
// 返回【包名】  
aClass.getPackageName()

Constructor

// 通过Class对象取得 对应参数列表【双参(String,Integer)】 的 公有构造器
Constructor constructor = aClass.getConstructor(String.class,Integer.class);
// 通过构造器实例化对象,参数列表与构造器对应
Object o = constructor.newInstance("text",666);

// 通过Class对象取得 对应参数列表 的 构造器；包括私有
Constructor constructor = aClass.getDeclaredConstructor();
// 开放私有访问限制
constructor.setAccessible(true);

Field

// 通过Class对象取得一个成员变量
Field field = aClass.getField(varName);
// 通过Class对象取得public成员变量列表
Field[] fields = aClass.getFields();
// 通过Class对象取得全部成员变量列表
Field[] fields = aClass.getDeclaredFields();

// 获取变量 【Field】.get(对象名)
field.get(o);
// 修改变量 【Field】.set(对象名,值)
field.set(o,666);
// 开放私有访问限制
field.setAccessible(true);

Method

// 通过Class对象取得一个成员方法
Method aMathod = aClass.getMethod(methodName);
// 调用方法 【Method】.invoke(对象名)
aMathod.invoke(o);
// 开放私有访问限制，会略微提升效率
aMathod.setAccessible(true);

posted @ 2022-04-09 16:54 Raink 阅读(48) 评论(0) 编辑收藏举报

刷新页面返回顶部

Raink

Java API (0409)

包装类

装箱拆箱

类型转换

Integer

Character

判断

转化

String

String

String Buffer

StringBuilder

区别

File

File

创建

修改

判断

获取

自定义获取

文件名排序

Date

集合

Array

ArrayList

LinkList

HashSet

HashMap

Queue

工具类

Object

Reflection 反射

Properties

Class

Constructor

Field

Method

公告