byte short char :这三种类型相互运算是以int为结果类型
原因:以为他们之 间相互运算可能存在超过其原数据类型的存储空间
/:两个整数做运算其结果一定是整数,因为最高类型为整数
解决:通常可给其中一个整数*1.0来转换类型
int a=5;
int b=a/2 // 2
能算则算,不能算就在一起吧
int a=10;
char c='a';
System.out.println(a+5); // 15
System.out.println(a+c+"test"); // 107test
System.out.println("test"+a+111); // test10111
String是不可变的字符串
只要是以“xxx”方式创建的字符串,都会存储在堆内存的字符串常量池中,相同内存只会存储一份(节约内存)
String name1="name";
String name2="name";
System.out.println(name1==name2); // true
String name11=new String("nema");
String name22=new String("nema");
System.out.println(name11==name22); // false
静态代码块只执行一次
编译看左边 运行看右边
就是一种特殊的局部内部类;所谓匿名,是值不需要为此类指定名字
实质:匿名内部类编译成一个子类,子类会立马创建一个对象出来
new 类或者接口(参数){
类体(一般是方法重写)
}
解决:字符串拼接时候需要前缀、后缀、分隔符
StringJoiner stringJoiner=new StringJoiner(",","[","]");
stringJoiner.add("a");
stringJoiner.add("b");
stringJoiner.add("c");
System.out.println(stringJoiner); // [a,b,c]
BigDecimal bigDecimal =new BigDecimal (double) 此种方式也存在精度丢失。可以下来解决
单列集合
特点:增删改查性能就较好
哈希值:就是一个int的数值,每一个java对象都有,Object类的方法 hashCode返回其自己的哈希值
,不同对象的哈希值不同,但也可能存在相同(int -21亿,21亿,如果对象唱过21亿则会出现:哈希碰撞)
无序:使用元素的哈希值和数组的长度求余计算出存入的位置
扩容:
低层: 哈希表 ,但是它的每一个元素都多了一个双链表的机制记录前后的元素的位置
低层:红黑树
格式:数据类型…参数名称
特点:可不传数据、可传一个、可传多个、可传数组
注意:形参中只能有一个可变参数,只可以放在最后
public static void main(String[] args) {
testParam();
testParam(1);
testParam(2,3);
testParam(new int[]{1,2,3,4,5});
}
public static void testParam(int...param){
System.out.println("----------:"+param.length);
}
用于操作集合和数组的数据
特点:Stream流大量的集合了Lambda编程分格,更加强大和简洁的操作集合和数组
filter:过滤
sorted:排序
limit:限制数量
skip:跳过
distinct:去重
concat:多流合并为新流
map:映射
List<String> list=new ArrayList();
list.add("公司是");
list.add("公司啊");
list.add("阿萨德");
list.add("规范的");
list.add("轨道射灯");
list.stream().filter(s -> s.startsWith("公司") && s.length() == 3).sorted().forEach(s -> System.out.println(s));
返回对象
List<String> newList = list.stream().filter(s -> s.startsWith("公司") && s.length() == 3).sorted().collect(Collectors.toList());
构造方法形参:文件路径
注: File.separator 根据系统获取分隔符-----兼容
try( InputStream inputStream =new FileInputStream("F:"+File.separator+"a.txt");
OutputStream outputStream=new FileOutputStream("F:"+File.separator+"c.txt")) {
byte[] bytes=new byte[1024];
int len=0;
while ((len=inputStream.read(bytes))!=-1){
outputStream.write(bytes,0,len);
}
}catch (Exception e){
}
try( Reader reader=new FileReader("F:"+File.separator+"a.txt");
Writer writer= new FileWriter("F:"+File.separator+"b.txt")) {
char[] chars=new char[6];
int len=0;
while ((len=reader.read(chars))!=-1){
writer.write(chars,0,len);
}
writer.flush();
}catch (Exception e){
}
本质: 频繁向磁盘写文件浪费性能。 则输出的数据写入内存,当刷新或关闭,则从内存写入到磁盘文件。当写入内存的数量达到一定的程度也会写入,
字符流输出数据后,要刷新或者关闭(关闭会自动刷新)字符流,写出去的数据才会生效。
try ( InputStream fileInputStream = new FileInputStream("f:" + File.separator + "a.txt");
FileOutputStream fileOutputStream=new FileOutputStream(new File("f:" + File.separator + "b.txt"));){
int available = fileInputStream.available(); // 数据量过大不可
byte[] buff=new byte[available];
int len=0;
while ((len=fileInputStream.read(buff))!=-1){
fileOutputStream.write(buff,0 ,len);
}
}catch (Exception e){
e.printStackTrace();
}
包装原始数据,提升读写性能: 自带8KB的缓冲池,构造参数可自定义修改大小
本质:从磁盘那一次性读取缓冲区大小的数据到内存,从内存一次性读取缓冲区大的数据到磁盘
包装原始数据,提升读写性能: 自带8KB的缓冲池,构造参数可自定义修改大小
本质:从磁盘那一次性读取缓冲区大小的数据到内存,从内存一次性读取缓冲区大的数据到磁盘
String line="";
while ((line=bufferedReader.readLine())!=null){
bufferedWriter.write(line);
}
本质:获取原始字节流,按照指定字符集编码转为输入或输出流。
直接输出什么就直接打印什么(高性能)
System.out.println() :就是打印流
PrintStream printStream=new PrintStream("f:"+ File.separator+"aa.txt");
printStream.println(97);
printStream.println(‘a’);
printStream.println("阿萨");
将数据和其数据类型一起输入输出
try( DataOutputStream dataOutputStream=new DataOutputStream(new FileOutputStream("f:"+ File.separator+"date.txt"))) {
dataOutputStream.writeInt(1);
dataOutputStream.writeDouble(2.2);
dataOutputStream.writeUTF("测试");
}catch (Exception e){
}
try( DataInputStream dataInputStream=new DataInputStream(new FileInputStream("f:"+ File.separator+"date.txt"))) {
int i = dataInputStream.readInt();
System.out.println(i);
double v = dataInputStream.readDouble();
System.out.println(v);
String s = dataInputStream.readUTF();
System.out.println(s);
}catch (Exception e){
序列化:把java对象导入到文件中去
反序列化:将文件中的java对象读出来
try( ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("f:"+File.separator+"object.txt"))) {
Emp emp=new Emp();
emp.setEmpno(111);
emp.setEname("xusx");
emp.setJob("coder");
objectOutputStream.writeObject(emp);
}catch (Exception e){
}
transient :标识此成员变量不参与序列化
private transient String ename;
try(ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("f:"+File.separator+"object.txt"))) {
Emp emp = (Emp) objectInputStream.readObject();
System.out.println(emp);
}catch (Exception e){
}
多个对象如何序列化
是用ArryList集合中放入对象,ArryList已实现Serializable
Properties properties=new Properties();
properties.load(new FileReader("a.properties"));
String name = properties.getProperty("name");
将整个Properties 中key-value 全部重新写入文件
Properties properties=new Properties();
properties.setProperty("name","xusx");
properties.store(new FileWriter("a.properties"),null);
一种数据格式来存储复杂的数据格式和数据关系
jar:dom4j解析xml
SAXReader saxReader=new SAXReader();
Document document = saxReader.read("users.xml");
Element rootElement = document.getRootElement();
List<Element> elements = rootElement.elements();
for (Element element:elements){
Element name = element.element("name");
System.out.println(name.getText());
Attribute id = element.attribute("id");
String value = id.getValue();
System.out.println(value);
System.out.println(element.getName());
}