标签：Java String 0409 System API str new Integer public
目录包装类
装箱拆箱
// 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
保存字符串
常量，不可修改
- 常用方法
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
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);
标签：Java,String,0409,System,API,str,new,Integer,public 来源： https://www.cnblogs.com/raink3/p/16122581.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。