初学Java总结（二）
垃圾分代回收机制-当程序启动时，系统会对堆内存进行监测，若堆内存使用比例超过70%就会启动GC(Garbage Collector)通知系统进行回收。堆内存分为新生代和老生代，新生代又分为伊甸园区和幸存区，创建的新对象首先放入伊甸园区，然后扫描一次，若无用则回收，若依然在用则放入幸存区，然后进行多次扫描，无用则回收，有用就移动到老生代（扫描…无用则回收）ObjectObject类是J...
·
垃圾分代回收机制
-当程序启动时，系统会对堆内存进行监测，若堆内存使用比例超过70%就会启动GC(Garbage Collector)通知系统进行回收。
- 堆内存分为新生代和老生代，新生代又分为伊甸园区和幸存区，创建的新对象首先放入伊甸园区，然后扫描一次，若无用则回收，若依然在用则放入幸存区，然后进行多次扫描，无用则回收，有用就移动到老生代（扫描…无用则回收）
Object
- Object类是Java中所有类的顶级父类。
- 对象.getClass()——返回值是该对象的实际创建类型
- 对象.toString()——将对象转为字符串，并返回其地址值
- 对象1.equals(对象2)——比较两对象的地址值是否相等，可以重写
String
- String是一个最终类，没有子类
- String中的重要方法
- s.charAt(index)——根据字符串的下标返回指定字符
- s.length()——返回字符串长度值
- s.toCharArray()——将字符串转为字符数组
- new String(char[ ] c)——将字符数组转为字符串对象
- s1.compareTo(s2)——返回两个字符串对象字典排序的差值
- s.concat(s2)——将s2拼接到s的末尾
- s1.contains(s2)——判断s2是否是s1的子串
- s1.startsWith(s2)/s1.endsWith(s2)——判断s1是否以s2开头或结尾
- s1.equals(s2)——重写了Object中的方法（Object中之比较地址），比较地址值是否相等，如果不相等再比较内容是否一致
- s.getBytes(“utf-8”)——根据指定编码规则，返回一个字节数组
- s.indexOf(“asd”)——返回新串在s中第一次出现的下标值
- s.intern()——把字符串对象的引用转到常量池
- s.isEmpty()——判断是否是空串
- s.replace(“aa”,“bbb”)——将原字符串中的“aa”替换为“bbb”
- s.subString(7)/s.subString(2,7)——截取子字符串
- s.trim()——删除字符串首尾的空格
- String.valueOf(数据)——可以把所有的数据类型转换成新字符串返回
char c[]={'a','b','c'};
System.out.println(c);//abc
System.out.println(c.toString());//[C@15db9742
正则表达式（Pattern类）
- s.matches("(.)\1a{5,12}.*b?")——返回值为true或者false
- *为0次或多次，+为至少一次，?为至多一次
- s.replaceAll(“正则表达式”,“abc”)——将匹配到的字符（串）替换为“abc”
- s.split(“aa”)——以aa为分割点将原串切割为字符串数组
- String str=“TomAndJerry”;
//捕获组和使用捕获组不在一个表达式中只能用$n去使用其他的捕获组
System.out.println(str.replaceAll("(Tom)(.*)(Jerry)", “$3$2$1”));//输出JerryAndTom
包装类
- 自动封箱、自动拆箱
- 整数类型共享范围（-128,127）
Math类（java.lang.Math）
- `精确运算
BigDecimal bd1=new BigDecimal("2.1");
BigDecimal bd2=new BigDecimal("1.98");
System.out.println(bd1.subtract(bd2));
- String转double
DecimalFormat df=new DecimalFormat("#.#####");
String s1=df.format(d);
System.out.println(Double.parseDouble(s1));
System.out.println(Double.valueOf(s1).doubleValue());
Date类
-
Date date=new Date();
System.out.println(date);//输出当前系统日期—Sat Jul 27 17:41:11 CST 2019 -
//1、字符串转日期
String str=“2012-12-12 17:10:11”;
//指定日期转换的格式
SimpleDateFormat sdf=new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
//把字符串转成日期
Date date=sdf.parse(str);
System.out.println(date);//输出结果：Wed Dec 12 17:10:11 CST 2012 -
//2、日期转字符串
SimpleDateFormat sdf1=new SimpleDateFormat(“yyyy年MM月dd日 HH时mm分ss秒”);
//把日期转成字符串
Date date=new Date();//自定义时间：Date date=new Date(2019-1900,7-1,19);
String s=sdf1.format(date);
System.out.println(s);//输出结果：2019年07月27日 17时47分36秒 -
//jdk1.8time包下更新 只展示日期
LocalDate f=LocalDate.now();
System.out.println(f.plus(0,ChronoUnit.CENTURIES));//2019-07-27 -
//得到日历类里的信息2019-07-27,星期六
Calendar c=Calendar.getInstance();//获取当前时间
System.out.println(c.get(Calendar.DAY_OF_MONTH));//27
System.out.println(c.get(Calendar.DAY_OF_WEEK));//7
异常
- 自定义异常：
- 1、自定义一个异常类（继承 Exception）
- 2、在方法中有可能出异常的地方抛出异常
- 3、在调用方法出使用try/catch捕获异常
public class ExceptionDemo {
public static void main(String[] args) {
//调用时捕获异常
try {
String s = "";
test(s);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
//方法中抛出异常
public static void test(String m) throws InputErrorException {
if (m == "") {
throw new InputErrorException("输入数据有误！！！");
}
}
}
//创建异常类
class InputErrorException extends Exception {
public InputErrorException(String message) {
super(message);
}
}
finally
public class ExceptionDemo7 {
public static void main(String[] args) {
System.out.println(m()); //4
}
public static int m(){
int i=1;
try {
return i=4;//若为对象，则此处挂起的是对象的地址值
}
finally {
i++;
System.out.println(i); //5
//return i;//若此处没有return，则return i=4;
}
}
}
集合（Collection）
- //创建集合对象
Collection c=new ArrayList<>();
//存储/添加元素
c.add(“abc”);
//创建列表集合对象
ArrayList list=new ArrayList();
for(int i=0;i<6;i++)
list.add("abc");
System.out.println(list);//[abc, abc, abc, abc, abc, abc]
// //插入元素---添加元素
list.add(5, "123");
System.out.println(list);//[abc, abc, abc, abc, abc, 123, abc]
- ArrayList底层是由数组来实现的，默认数组的初始长度是10，根据底层右移运算进行扩容，
- 每次在原来的基础上扩容一半 10-- 15-- 22 --33
- LinkedList底层是由节点（静态内部类）来进行存储元素的。底层内存不连续，不需要扩容，增删元素效率较高、查询元素效率较低
- Vector
- 底层基于数组，扩容是基于三目运算符默认增加一倍，但是可以指定增量，如果增量不为0就可以按照增量进行数组的扩容
//调用方法返回古老的迭代器
Enumeration<String> e=v.elements();//只有Vector有这个方法
//迭代遍历
//使用while循环
//获取元素
String s=e.nextElement();
System.out.println(s);
//删除元素---直接删除集合元素
v.remove(s);
while(e.hasMoreElements()){//判断是否还有元素
}
- Iterator(迭代器)
//获取新的迭代器
Iterator<String> it=list.iterator();
//迭代遍历
while(it.hasNext()){//判断后面是否还有元素
//获取元素
String s=it.next();
System.out.println(s);
//直接删除集合元素?不能
//list.remove(s);
//是改变底层比较的状态值---由true变为false
it.remove();//这样才可以删除
}
System.out.println(list);//[]
-
Stack（栈）
-
//创建Stack对象
Stack s=new Stack<>();
s.push(“1”);//入栈
s.pop();//出栈（获取栈顶元素并删除）
s.peek();//获取栈顶元素不删除
Set：不能存储重复元素
- HashSet
- 底层基于HashMap来实现的，是由数组+链表进行存储元素，不能存储重复元素，不能保证存入数据的顺序，底层数组长度（容量）一定是2En
- TreeSet会自动对存储的元素进行排序—升序—自然排序对象存储在TreeSet中想要进行排序，保证对象对应的类实现Comparable接口，重写compareTo方法去指定具体的排序规则
- Queue(队列)
- //创建集合对象
Queue q=new LinkedList<>();
映射（Map<k,v>）
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo1 {
public static void main(String[] args) {
//创建映射对象
Map<String, Integer> map=new HashMap<>();
//添加元素
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
map.put("d", 4);
//重复键--覆盖
map.put("a", 6);//{a=6, b=2, c=3, d=4}
//判断映射是否包含键
//System.out.println(map.containsKey("c"));
//判断是否包含值
//System.out.println(map.containsValue(7));
//把映射中的键值对（Entry对象）存放Set集合中进行返回
//Set<Map.Entry<String, Integer>> s=map.entrySet();
//根据键获取值---键不存在返回null
//System.out.println(map.get("u"));
//返回的把所有的键存放到Set集合中
//Set<String> set=map.keySet();
//根据键删除键值对
//map.remove("a");
//删除键值对
//同时满足才能删除
//map.remove("u", 3);
//把映射的所有值存储到一个集合中进行返回
//Collection<Integer> c=map.values();
System.out.println(map);//{a=1, b=2, c=3, d=4}
}
}
- 遍历映射
两种方法：
//1.获取映射中所有的键
Set<String> set=map.keySet();
//遍历键
//增强for循环
for (String string : set) {
//由键获取指定值
System.out.println(string+"="+map.get(string));
}
//2.获取所有的键值对
for(Map.Entry<String, Integer> entry:map.entrySet()){
//每个entry就是具体的entry对象就是具体的键值对
System.out.println(entry.getKey()+"="+entry.getValue());
}
- 映射的实现类：(映射不是集合)
- 1、HashMap可以允许存储null值和null键，默认初始容为16，默认扩容是增加一倍，如果指定初始容量，指定的值在2En~2E(n+1)，那么底层真实的容量就是2E(n+1) 异步式线程不安全的集合
- 2、HashTable不允许存储null值和null键，默认初始容量是11，默认扩容是增加一倍再加一 11—22+1–46+1，如果指定初始容量底层真实的初始容量就是多少 同步式线程安全的集合
File
import java.io.File;
import java.io.IOException;
public class FileDemo1 {
public static void main(String[] args) throws IOException {
//创建File类对象
//在创建对象过程中不会去检测真实的路径
//只是在根据给定的路径创建对象
File file=new File("D:\\a.txt");//此时未在该目录下创建真实的文件
//重命名---剪切（路径不一样）
file.renameTo(new File("D:\\javase\\2.txt"));//文件存储的路径
//创建文件---空文件
//boolean b=file.createNewFile();
//创建文件夹---目录
//不仅可以创建文件夹或者目录还可以创建多级目录
//boolean b=file.mkdirs();
//可以删除文件（有无内容），删除空目录
//直接删除---不会放在回收中
boolean b=file.delete();
System.out.println(b);//删除成功返回true
//返回目录或者文件的名称
System.out.println(file.getName());
//返回所在目录路径
System.out.println(file.getParent());
//返回所在位置的路径以及名称
System.out.println(file.getPath());
}
}
- 获取当前目录下的所有文件以及文件夹
public class FileDemo2 {
public static void main(String[] args) {
//创建文件类对象
File file=new File("D:\\");
//获取当前目录下的所有文件以及文件夹的信息
File[] fs=file.listFiles();
//遍历数组
for (File f : fs) {
System.out.println(f);
}
//判断是否是文件
System.out.println(file.isFile());
//判断是否是文件夹---目录
System.out.println(file.isDirectory());
}
}
- 删除文件
public class FileText1 {
public static void main(String[] args) {
//获取文件类对象
File file=new File("D:\\a");
//调用方法
deleFile(file);
}
//删除文件
public static void deleFile(File file){
//判断是否是文件夹
if(file.isDirectory()){
//获取当前文件夹下所有的信息
File[] fs=file.listFiles();
//遍历数组
for (File f : fs) {
//把数组里的每一个文件类对象再次传入到本方法中
deleFile(f);
}
}
//删除文件---删除空目录
file.delete();
}
}
IO流
- 四大基本流
- FileWriter fw=new FileWriter(“D:\1.txt”);
fw.write(“hahahaahhaha”);//开发时需要处理异常
fw.flush();//冲刷缓冲区
fw.close();
//强制对象值为null
//把对象置为无用对象，在某个时间进行垃圾回收
fw=null; - FileReader reader=new FileReader(“D:\2.txt”);
//读取数据
//返回的是读取到字符的编码值
//读取结束的标志就是返回-1
System.out.println((char)reader.read());
int len=-1;//提供变量供给读取数据覆盖
while((len=reader.read())!=-1){//避免读取两次情况
System.out.println(len);
}
//关流—输入流没有缓冲区
reader.close(); - 自建缓冲区
char[] cs=new char[3];
int len=-1;
//reader.read(字符数组)--返回值就是每次读取到的字符个数
while((len=reader.read(cs))!=-1){//读取到的内容存放到数组
System.out.println(new String(cs,0,len));
}
- 利用文件流进行文件复制
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
long start=System.currentTimeMillis();
FileReader reader=new FileReader("D:\\b.txt");//文件不存在会报错
FileWriter writer=new FileWriter("D:\\a.txt");//文件不存在会新建
char[] c=new char[1024*64];//自建缓冲区
int count=-1;
while((count=reader.read(c))!=-1){
writer.write(c);
writer.flush();
}
reader.close();
writer.close();
reader=null;
writer=null;
long end=System.currentTimeMillis();
System.out.println(end-start);
}
}
- 字节流
//创建字节输出流对象---没有缓冲区 true表明文件可追加,即不删除原有信息
FileOutputStream os=new FileOutputStream("D:\\c.txt",true);
//写出数据
os.write("中".getBytes());//获取字节数组
FileInputStream fis=new FileInputStream("D:\\1.txt");
//读取数据 结束标志是-1
//System.out.println(is.read());
//自建缓冲区
byte[] bs=new byte[10];
int len=-1;
while((len=fis.read(bs))!=-1){
System.out.println(new String(bs,0,len));
}
- BufferedReader
BufferedReader br=new BufferedReader(new FileReader("D:\\a123.txt"));
//读取一行---结束标志null
String str="";
while((str=br.readLine())!=null){
System.out.println(str);
}
BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\b.txt"));
//写出数据
bw.write("abc");
bw.newLine();//换行---不管具体什么的操作系统
bw.write("123");
合并流
public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException {
//提供输入流---提供待合并的数据
FileInputStream in1=new FileInputStream("D:\\a1.txt");
FileInputStream in2=new FileInputStream("D:\\a2.txt");
FileInputStream in3=new FileInputStream("D:\\a3.txt");
//创建Vector集合对象
Vector<FileInputStream> v=new Vector<>();
//把输入流对象添加到集合中
v.add(in1);
v.add(in2);
v.add(in3);
//获取到Enumeration---把集合中的所有输入流对象存放到e对象中
Enumeration<FileInputStream> e=v.elements();
//创建合并流对象---把含有输入流对象的e放到合并流对象中
SequenceInputStream sis=new SequenceInputStream(e);
//文件字节输出流
FileOutputStream os=new FileOutputStream("D:\\a2.txt");
//通过合并流对象进行统一读取数据---合并
byte[] bs=new byte[1024*1024*10];
int len=-1;
while((len=sis.read(bs))!=-1){
//写出合并之后的数据
os.write(bs, 0, len);
}
//关流
sis.close();
os.close();
}
}
- 序列化
public class ObjectOutputStreamDemo {
public static void main(String[] args) throws IOException {
//创建对象
Person p=new Person();
//给对象属性赋值
p.setName("lili");
p.setAge(10);
//开始进行序列化---创建序列化类的对象
ObjectOutputStream oos=new ObjectOutputStream
(new FileOutputStream("p.data"));
//写出对象
oos.writeObject(p);//把对象进行序列化
//关流
oos.close();
}
}
- 反序列化
public class ObjectInputStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//创建反序列化对象
ObjectInputStream ois=new ObjectInputStream
(new FileInputStream("p.data"));
//读取对象---保证获取的是传入的对象
Person p=(Person)ois.readObject();
//关流
ois.close();
//获取对象属性
System.out.println(p.getName()+","+p.getAge());
}
}
-可变参数
可变参数—表示可以接收多个这样类型的参数
可变参数底层就是一个数组，参数的值依次存放到数组元素中
可变参数一定在最右边而且只有一个
public static int m(int m,int... n){//n[]
-创建配置文件
public class PropertiesDemo1 {
public static void main(String[] args) throws IOException {
//创建对象
Properties p=new Properties();
//添加元素---键和值---字符串
p.setProperty("name", "lili");
p.setProperty("gender", "女");
p.setProperty("age", "10");
//把要存储的内容传输到配置文件中---配置文件后缀必须是.properties
//第二个参数---文件的内容解释
p.store(newFileOutputStream("p.properties"),"");
}
}
public class PropertiesDemo2 {
public static void main(String[] args) throws IOException, IOException {
//创建对象
Properties p=new Properties();
//加载指定配置文件
p.load(new FileInputStream("p.properties"));
//获取配置文件的内容
//根据键获取值
System.out.println(p.getProperty("name"));
//根据键获取值
System.out.println(p.getProperty("name", "tom"));
//列出配置文件信息
p.list(System.out);
}
}
快速构建 Web 应用程序
更多推荐
0
0- 0
已为社区贡献1条内容
所有评论(0)