一、File练习
package com.javase.day17;
import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestFile {
// 在相对路径中创建1.txt 文件 工程目录下
// 在c盘的根目录下创建文件2.txt， 并修改其修改的时间 1970-8-9。
// 在c盘的根目录下创建文件c:/7/7/2.txt
// 将指定的目录下的，指定的后缀的文件全部删除
// 使用递归将某个目录下的所有的文件以及子目录中的文件 文件的个数的统计。
// 使用递归实现，将指定的目录以及其子目录全部删除。
public static void main(String[] args) {
// 从当前系统动态获得的路径分隔符 和 目录分隔符
System.out.println(File.pathSeparator);// ;
System.out.println(File.separator);// \
// deleteFilesBySuffix("c:\\class\\501", "class");
test2();
test3();
Integer.parseInt("21");
}
// 在res 的相对目录中，创建 或者删除指定的文件
static void test1() {
File file = new File("." + File.separator + "res" + File.separator
+ "1.txt");
if (file.exists()) {// 文件存在，删除，
file.delete();
} else {// 不存在，创建新的
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 在c盘的根目录下创建文件2.txt， 并修改其修改的时间 1970-8-9。
static void test2() {
File file = new File("F:\\2.txt");
if (!file.exists()) {
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
// 修改 time 要求是 距离 1970 年1月1日 的毫秒的时间差
try {
file.setLastModified(Long
.parseLong(dateToStamp("1970-05-20 13:14:20")));
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
}
// file.lastModified()
}
// 在c盘的根目录下创建文件c:/7/7/2.txt
static void test3() {
File file = new File("F:\\88\\88");
// 先创建目录
// file.mkdir() 只能创建一层
file.mkdirs();
// 再创建文件
File file2 = new File(file, "2.txt");
if (!file2.exists()) {
try {
file2.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
*删除指定目录下的指定的后缀的文件
*
* @param path
* @param suffix
*/
static void deleteFilesBySuffix(String path, String suffix) {
File file = new File(path);
// 得到当前目录下的所有的文件
File[] files = file.listFiles();
// 遍历所有的文件，如果文件的名字以suffix 结尾 就删除
for (File file2 : files) {
// 获得文件的名字
String name = file2.getName();
if (name.endsWith(suffix)) {
file2.delete();
}
}
}
static int counter;
// 使用递归将某个目录下的所有的文件以及子目录中的文件 文件的个数的统计。
static void countDirFile(File file) {
if (file.isFile()) {// file 是文件
counter++;
} else {// file 是目录
// 得到file 目录下的所有的文件夹和文件的列表
File[] files = file.listFiles();
// 遍历 使用同样的方式处理每一个文件对象
for (File file2 : files) {
countDirFile(file2);
}
}
}
// 使用递归实现，将指定的目录以及其子目录全部删除。
// 使用程序删除一个目录，必须把目录中的内容清空才能删除，只能删除空目录。
static void delDirectroy(File file) {
if (file.isFile()) {// file 是文件
file.delete();
} else {// file 是目录
// 得到file 目录下的所有的文件夹和文件的列表
File[] files = file.listFiles();
// 遍历 使用同样的方式处理每一个文件对象
for (File file2 : files) {
delDirectroy(file2);
}
// 删除当前空目录
file.delete();
}
}
/*
* 将时间转换为时间戳
*/
public static String dateToStamp(String s) throws ParseException {
String res;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss");
Date date = simpleDateFormat.parse(s);
long ts = date.getTime();
res = String.valueOf(ts);
return res;
}
}
二、Random
java.util.Random
用于获得随机数的。
boolean nextBoolean()
返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean 值。
int nextInt(int n)
返回一个伪随机数，它是取自此随机数生成器序列的、在0（包括）和指定值（不包括）之间均匀分布的 int 值。
三、Runtime
Runtime：运行时，是一个单例类。
public class Runtimeextends Object每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。
应用程序不能创建自己的Runtime 类实例。
import java.io.IOException;
public class TestRuntime {
public static void main(String[] args) throws IOException {
//获得这个Runtime 的唯一的实例
Runtime runtime = Runtime.getRuntime();
//常用方法
runtime.freeMemory();
runtime.totalMemory();
//等价的gc 调用
runtime.gc();
System.gc();
//等价 结束 jvm
//System.exit(0);
//runtime.exit(0);
//用于执行本地的程序
//runtime.exec("C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQScLauncher.exe");
//使用指定的程序打开指定的文件
//运行了一个程序 Process 运行程序对象。
Process process = runtime.exec("notepad.exe src/com/bjsxt/normalclass/TestRuntime.java");
try {
//程序在此等候3秒
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//杀死进程
process.destroy();
}
}
四、枚举Enum
一种特殊的类类型。
所有的枚举类都默认继承了父类Enum ，其中定义了一些方法，并重写了toString。
每个枚举的静态的成员，都分配了一个默认的值。通过成员调用ordinal() 方法获得。第一个成员的值为0，依次递增。
枚举类中的元素是无法通过下标值来访问的，如果你想指定访问枚举类中的某个值，你只能直接写出它们的值，除此之外，别无他法。但是枚举类有一个values()方法，这个方法可以将枚举类转换成一个枚举类型的数组，转换成数组之后我们就可以通过下标来访问我们的枚举类中的值。
枚举使用的范围：
如果某些变量的值的范围是固定的，不想被随意破坏的，可以将该变量的类型定义为枚举类型。
import com.bjsxt.util.MyUtil;
public class TestEnum {
public static void main(String[] args) {
Student student = new Student("如花", 30, Gender.male);
System.out.println(student);
System.out.println(Gender.male.ordinal());
System.out.println(Gender.female.ordinal());
//获得当前枚举类的所有的实例成员。
Gender[] values = Gender.values();
//随机打印星期的某一天
System.out.println(Week.values()[MyUtil.getRandomNumber(0, Week.values().length)]);
//枚举在switch 中的用法
Week week = Week.values()[MyUtil.getRandomNumber(0, Week.values().length)];
switch(week){
case 星期一:
break;
}
}
}
class Student{
private String name;
private int age;
private Gender gender;
Student(String name, int age, Gender gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]";
}
}
enum Gender{
//是final 的 static 的public 的成员 本类的实例。
male,female
}
enum Week{
星期一,星期二,星期三,星期四,星期五,星期六,星期日
}
五、Date
字母日期或时间元素表示示例
G Era 标志符 Text AD
y 年Year 1996; 96
M 年中的月份Month July; Jul; 07
w 年中的周数Number 27
W 月份中的周数Number 2
D 年中的天数Number 189
d 月份中的天数Number 10
F 月份中的星期Number 2
E 星期中的天数Text Tuesday; Tue
a Am/pm 标记 Text PM
H 一天中的小时数（0-23） Number 0
k 一天中的小时数（1-24） Number 24
K am/pm 中的小时数（0-11） Number 0
h am/pm 中的小时数（1-12） Number 12
m 小时中的分钟数Number 30
s 分钟中的秒数Number 55
S 毫秒数Number 978
z 时区General time zone Pacific Standard Time; PST; GMT-08:00
Z 时区RFC 822 time zone -0800
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//关于日期的处理
//1:获得日期的具体的信息
//2:XXXX年XX月XX日 XX时XX分XX秒 日期的格式化打印
//3:对于指定格式的日期的字符串，生成一个日期对象
public class TestDate {
public static void main(String[] args) throws ParseException {
Date date = new Date();
//常用方法
System.out.println(date.toString());
//本地的字符串形式
System.out.println(date.toLocaleString());
//获得当前时间
System.out.println(date.getTime());
System.out.println(System.currentTimeMillis());
//获得各个时间的字段的值
System.out.println(date.getYear());//118 距离1900年的时间差
System.out.println(date.getDate());//日期 31
System.out.println(date.getMonth());//4 java 中的月份是0 序 [0-11]
System.out.println(date.getDay());// 4星期几 java 的中星期也是0 序 美国的星期日是一个星期的第一天
System.out.println(date.getHours());//11
System.out.println(date.getMinutes());//15
System.out.println(date.getSeconds());//39
System.out.println(date.getTimezoneOffset());//东八区 -480分钟
//修改日期的值。
//date.setDate(date);
//判断某个日期是否在某个日期之前或者之后
System.out.println(date.before(new Date()));
System.out.println(date.after(new Date()));
//实现了内部比较器
//date.compareTo(anotherDate)
//日期的格式化显式 XXXX年XX月XX日 XX时XX分XX秒
System.out.println(date.toLocaleString());
//使用日期格式化对象对日期对象进行格式化
//pattern 定义的模式 格式
DateFormat format = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
//格式化日期对象
String dateStr = format.format(date);
System.out.println(dateStr);
//对指定的日期字符串生成一个日期对象。
dateStr = "2018-5-31 11:27:27";
format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date2 = format.parse(dateStr);
System.out.println(date2.toString());
}
}
六、Calendar 日历类
import java.util.Calendar;
public class TestCalendar {
public static void main(String[] args) {
//创建 Calendar 对象
Calendar calendar = Calendar.getInstance();
//calendar 是Date 的替代类，功能更加的强大。
System.out.println(calendar);
//获得指定字段的值
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH));
System.out.println(calendar.get(Calendar.DATE));
System.out.println(calendar.get(Calendar.HOUR));
System.out.println(calendar.get(Calendar.MINUTE));
System.out.println(calendar.get(Calendar.SECOND));
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//31
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//5 一个星期的第几天 从1开始算
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));//一个月的第几个星期
System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));//过了几周的时间了。小于等于上面的
System.out.println(calendar.get(Calendar.WEEK_OF_YEAR));//一年中的第几周
System.out.println(Calendar.HOUR_OF_DAY);
// 修改时间
// calendar.set(field, value);
calendar.add(Calendar.YEAR, 2);
//本地的一周的第一天是星期几
System.out.println(calendar.getFirstDayOfWeek());
}
}
七、集合
1：collection framework。 集合框架。
2：学习各种不同功能和特点的容器类。
3：数组也可以看作一种简单的容器。元素要求连续，元素有序号。数组这种容器有很多的缺点。
java 提供了一整套的解决的方案。
整体了解一下：
1：序列 Sequence ：容器中的对象是有序号的，有序的（添加的顺序）。
2：集 Set ：这样的容器中对象是无序的，唯一的。
3：映射 Map ： 一个对象是一组数据 key--value即键--值--键值对儿。可以通过key 值找到和key对应的value 的值。
Collection： 顶层的接口。定义了一系列的规范。 描述的容器的某些功能。功能都是针对容器中的元素制定的。
Collection 中定义的功能 对 容器中元素的要求 是： 无序的（没有顺序添加，Collection 中没有提供根据序号添加和访问元素的方法），不唯一的（对子类的实现往容器中添加元素的时候，可以添加重复的元素）。
Collection 容器的特点： 无序，不唯一。
---List
---Set
八、List -- ArrayList
List 是 Collection 直接的子接口。
List 特点： 元素有序（元素添加的序号），不唯一。
List的实现的子类之一 ArrayList。
ArrayList 特点：元素有序（添加插入的顺序），不唯一，元素内容可以是 null.
import java.util.ArrayList;
import java.util.Iterator;
public class TestArrayList {
public static void main(String[] args) {
//创建对象。
//自动类型推断
ArrayList list = new ArrayList<>();
//增
// list.add(1);
// list.add("abcd");
// list.add("abcd");
list.add(new Student(12,"小明"));
//插入 元素序号0 序
// list.add(0, "efgh");
// list.add(3, "3456");
list.add(new Student(10,"小刚"));
//不能跳着插入元素
// list.add(7, "7891");
//删
list.remove(1);
list.remove(new String("abcd"));
//记得重写equals 方法
list.remove(new Student(10,"小刚"));
//改
// list.set(1, "7890");
//查
System.out.println(list.get(2));
//其他的方法
list.size();//元素的个数
list.isEmpty();//是否为空
list.contains(7890);//是否包含指定的元素
list.clear();//清空元素
// list.lastIndexOf(o)
// list.ensureCapacity(minCapacity); 扩容
// list.trimToSize(); 去掉空白元素
//遍历容器的元素
//for 使用基本的for 循环实现遍历元素
int size = list.size();
for(int i=0;i< size;i++){
Student stu = list.get(i);
//TODO
System.out.println(stu);
}
// 使用foreach 遍历元素 底层使用迭代器实现。
for (Student s : list) {
//TODO
System.out.println(s);
}
//使用迭代器
//得到容器对象上的迭代器对象
//指明迭代器迭代的元素的类型。
Iterator iterator = list.iterator();
while(iterator.hasNext()){
Student next = iterator.next();
System.out.println(next);
//next
}
System.out.println(list);
}
}
class Student{
private int age;
private String name;
Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Student [age=" + age + ", name=" + name + "]";
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
九、迭代器
增强的for 循环：遍历容器底层使用迭代器实现。
十、泛型：
又称为参数化类型---generic type。
泛型给容器类带来的好处：
1：避免了因为误操作而在某种容器中添加了不希望添加的类型的元素。 控制容器元素的类型单一。
2：避免了在访问容器元素的过程中，将Object 对象 强制转换为 需要的类型。
ArrayList list = new ArrayList<>();
Iterator iterator = list.iterator();
while(iterator.hasNext()){
Student next = iterator.next();
System.out.println(next);
//next
}
1：ArrayList 底层使用 Object[] elementData 数组实现。
2: 初始化容量为10。
3：扩容的规则，10-->15--->22 每次扩容的元素的个数为 现有容量的 50%。
优点：
1：通过下标遍历效率很快。
2：所有对数组元素的操作都提供了封装的方法，使用很方便。
3：可以实现自动扩容。
缺点：
1：根据内容查找元素效率相对较低。
2：删除，插入元素，因为需要移动大量的元素，所以效率比较低。
总结：ArrayList是一个性能很优良的容器类。使用率很高。
例：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.bjsxt.util.MyUtil;
public class TestArrayList1 {
public static void main(String[] args) {
List list =new ArrayList<>();
for(int i=0;i<20;i++){
list.add(Integer.toString(MyUtil.getRandomNumber(4, 7)));
}
list.add(null);
System.out.println(list);
//删除内容为 4 的字符串。
// int size = list.size();
// for(int i=0;i
// if("4".equals(list.get(i))){
// list.remove(i);
// i--;
// }
// }
System.out.println(list);
//获得容器对象上的迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String str = iterator.next();
if("4".equals(str)){
//在使用迭代器遍历元素的过程中，不要使用集合容器对象去修改元素，不要删除，添加元素。
//访问可以，使用迭代器自身的remove 方法没有问题。
list.remove(str);
}
}
System.out.println(list);
}
}
