public class VariableDemo3{ //主入口 public static void main(String[] args){ //byte byte b = 10; System.out.println(b); //short short s = 20; System.out.println(s); //int int i = 30; System.out.println(i); //long //如果要定义long类型的变量 //在数据值后面需要加一个L作为后缀 //L可以是大写的,也可以是小写的 //建议:使用大写。原因小写l与数字1长相相似 long l = 999999999999L; System.out.println(l); //float //float类型的数据后面要需要加一个F //F可以是大写也可以是小写 float f = 10.1F; System.out.println(f); //double double d = 20.2; System.out.println(d); //char char c ='中'; System.out.println(c); //boolean //只有true 和 false boolean o = true; System.out.println(o);
} }
键盘录入
导包
1
import java.util.Scanner; //导包的动作必须出现在类定义的上边
创建对象
1 2
Scanner sc = new Scanner(System.in); 上面这个格式里面,只有sc是变量名,可以变,其他的都不允许变
public class ScannerDemo1{ //程序主入口 public static void main(String[] args){ //2.创建对象,表示我现在准备要用Scanner这个类 Scanner sc = new Scanner(System.in); //3.接收数据 //变量i记录了键盘录入的数据 System.out.println("请输入整数"); int i = sc.nextInt(); System.out.println(i); } }
//3.短路逻辑运算符具有短路的效果 //简单理解:当左边的表达式能确定最终的结果,那么右边的就不会参与运行了 int a = 10; int b = 10; boolean result = ++a < 5 && ++b < 5; System.out.println(result); System.out.println(a); System.out.println(b); } }
三元运算符/三元表达式
1
格式: 关系表达式?表达式1:表达式2
计算规则
首先计算关系表达式的值
如果值为true,表达式1的值就是运算结果
如果值为false,表达式2的值就是运算结果
demo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
public class TernaryoperatorDemo1 { public static void main(String[] args) { //需求:使用三元运算符.获取两个数的较大值;
//分析: //1.定义两个变量记录两个整数 int number1 = 10; int number2 = 20;
public class switchDemo1 { public static void main(String[] args) { /*需求: 键盘录入星期数,显示今天的减肥活动 周一: 跑步 周二: 游泳 周三: 慢走 周四: 动感单车 周五: 拳击 周六: 爬山 周日: 好好吃一顿 */
//1.定义变量day记录星期数 System.out.println("请输入今天星期几:"); Scanner sc = new Scanner(System.in); int day = sc.nextInt(); //判断星期数的合法性 switch (day){ case 1: System.out.println("去跑步!"); break; case 2: System.out.println("去游泳!"); break; case 3: System.out.println("慢走!"); break; case 4: System.out.println("动感单车!"); break; case 5: System.out.println("打拳击!"); break; case 6: System.out.println("去爬山"); break; case 7: System.out.println("好好吃一顿!"); break; default: System.out.println("您输入的星期数不合法!"); break; } } }
public class CirculateTest4 { public static void main(String[] args) { /*需求: 小老虎吃包子，第三个包子有虫子，跳过。 */ for (int i = 1; i <= 5;i++){ if (i == 3){ continue; //continue表示结束这一次循环 } System.out.println("小老虎吃了第" + i + "个包子"); } } }
Demo2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
package Circulate;
public class CirculateTest5 { public static void main(String[] args) { /*需求: 小老虎吃包子，第三个包子就饱了。 */ for (int i = 1; i <= 5;i++){ if (i == 3){ System.out.println("小老虎吃了第" + i + "个包子,饱了!"); break; //break表示结束整个循环 } System.out.println("小老虎吃了第" + i + "个包子"); } } }
获取随机数
怎么获取随机数?
Java帮我们写好一个类叫Random，这个类就可以生成一个随机数。
使用步骤:
导包 — Random这个类在哪
1
import java.util.Random
创建对象 — 表示我要开始用Random这个类了
1
Random r = new Random();
生成随机数 — 真正开始干活了
1
int number = r.nextInt(随机数范围);
Demo1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
import java.util.Random;
public class CirculateTest9 { public static void main(String[] args) { //先获取一个随机数 //范围0~10
//1.导包 //2.创建对象 Random r = new Random(); //3.生成随机数 int number = r.nextInt(11);//随机数范围 0 ~ 10 } }
Demo2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
import java.util.Random;
public class CirculateTest9 { public static void main(String[] args) { //先获取一个随机数 //范围7~15
//1.导包 //2.创建对象 Random r = new Random(); //3.生成随机数 int number = r.nextInt(9) + 7;//随机数范围 0 ~ 10 } }
数组
什么是数组?
数组指的是一种容器,可以用来储存同种数据类型的多个值
一维数组
一维数组的定义:
格式1
1 2 3
数据类型[] 数组名 例: int [] array
格式2
1 2 3
数据类型 数组名[] 例 int array[]
一维数组的静态初始化
初始化:就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程
完整格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
简化格式:数据类型[] 数组名 = {元素1,元素2,元素3…};
例: int[] array = new int[]{11,22,33};
例: int[] array = {11,22,33};
Demo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
package Array;
public class ArrayDemo1 { public static void main(String[] args) { //需求1:定义数组储存5个学生的年龄 int[] arr1 = new int[]{11,12,13,14,15}; int[] arr2 = {21,22,23,24,25}; //需求2:定义数组储存5个学生的姓名 String[] arr3 = new String[]{"老大","老二","老三","老四","老五"}; String[] arr4 = {"laoda","laoer","laosan","laosi","laowu"}; //需求3:定义数组储存5个学生的身高 double[] arr5 = new double[]{1.71,1.72,1.73,1.74,1.75}; double[] arr6 = {1.81,1.82,1.83,1.84,1.85}; } }
一维数组的遍历
**数组遍历:**将数组中所有的内容取出来，取出来之后可以（打印，求和，判断..)
**注意:**遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印!
在java中,关于数组的一个长度属性,length
调用方式: 数组名.length
1 2 3 4 5 6 7 8 9 10
package Array;
public class ArrayDemo3 { public static void main(String[] args) { //1.定义数组 int[] arr = {1,2,3,4,5}; System.out.println(arr.length); } }
一维数组的动态初始化
动态初始化:初始化时只指定数组长度，由系统为数组分配初始值。
1 2 3 4
格式: 数据类型[] 数组名 = new 数据类型[数组长度]; 例: int[] arr = new int[3];
二维数组
二维数组的静态初始化
格式:
1
数据类型[][] 数组名 = new 数据类型[][] {{元素1,元素2},{元素1,元素2}};
public class twoDimensionDemo2 { public static void main(String[] args) { //1.利用动态初始化创建二维数组 int[][] arr = new int [3][5]; //3:表示二维数组长度为3，可以装3个一维数组 //5:表示每一个一维数组的长度都是5，可以装5个int类型的元素
//给二维数组赋值一个元素 arr[0][0] = 10; //遍历 for (int i = 0; i < arr.length; i++) { for (int i1 = 0; i1 < arr[i].length; i1++) { System.out.print(arr[i][i1] + " "); } System.out.println(); } } }
方法
方法( method)是程序中最小的执行单元。
**方法的定义:**把一些代码打包在一起,该过程称为方法的定义
**方法的调用:**方法定义后并不是直接运行的，需要手动调用才能执行，该过程称为方法调用。
最简单的方法的定义和调用
定义
格式:
1 2 3
public static void 方法名(){ 方法体(就是打包起来的代码); }
范例:
1 2 3
public static void playGame ( ) { 七个打印语句; }
调用
格式:
1
方法名();
范例:
1
playGame();
注意:方法必须先定义后调用，否则程序将报错
带参数的方法的定义和调用
定义
单个参数:
1 2 3
public static void 方法名(参数){ ... }
多个参数:
1 2 3
public static void 方法名(参数1,参数2,参数3){ ... }
调用
单个参数:
1
方法名(参数);
范例:
1 2 3
method(10);
method(变量);
多个参数:
1
方法名(参数1,参数2,...)
范例:
1 2
getSum(10,20); getSum(变量1,变量2);
注意:方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序将报错。
Demo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
package method;
import java.util.Scanner;
public class methodDemo2 { public static void main(String[] args) { //目标:掌握带参数方法定义的格式和调用格式 Scanner sc = new Scanner(System.in); System.out.println("请输入第一个数字"); int num1 = sc.nextInt(); System.out.println("请输入第二个数字"); int num2 = sc.nextInt(); getSum(num1,num2); } public static void getSum(int num1, int num2){ System.out.println("两个数的和为:" + (num1 + num2)); } }
形参和实参
形参:全称形式参数，是指方法定义中的参数
实参:全称实际参数，方法调用中的参数
注意:方法调用时，形参和实参必须一一对应，否则程序将报错。
带返回值的方法的定义和调用
什么是返回值?
方法的返回值其实就是方法的运行结果。
定义
格式:
1 2 3 4
public static 返回值类型 方法名(参数1){ 方法体; return 返回值; }
范例:
1 2 3 4
public static int getSum(int a,int b){ int c = a + b; return c; }
public class methodTest7 { public static void main(String[] args) { /*需求: 使用方法重载的思想，设计比较两个整数是否相同的方法。 要求:兼容全整数类型( byte,short,int,long) */ compare(20,20); } public static void compare(byte num1,byte num2){ System.out.println(num1 == num2); } public static void compare(short num1,short num2){ System.out.println(num1 == num2); } public static void compare(int num1,int num2){ System.out.println(num1 == num2); } public static void compare(long num1,long num2){ System.out.println(num1 == num2); }
}
类和对象
什么是类?
是共同特征的描述(设计图);
什么是对象?
是真实存在的具体实例。
如何得到对象?
1 2 3 4 5 6
public class 类名{
1.成员变量(代表属性的,一般是名词) 2、成员方法(代表行为的,一般是动词)
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
package Classes;
public class GirlFriend { //属性 String name; int age; String gender; //行为 public void sleep(){ System.out.println("女朋友在睡觉"); } public void eat(){ System.out.println("女朋友在吃饭"); } }
创建对象:
1
类名 对象名 = new 类名();
拿到对象能做什么?
对象.成员变量
对象.成员方法(…)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
package Classes;
public class GirlFriendTest { public static void main(String[] args) { //创建女朋友的对象 GirlFriend gf1 = new GirlFriend(); gf1.name = "红豆"; gf1.age = 18; gf1.gender = "female"; System.out.println(gf1.name); System.out.println(gf1.age); System.out.println(gf1.gender); gf1.eat(); gf1.sleep(); } }
public class Test { public static void main(String[] args) { //创建三个对象,并调用register方法 Student s = new Student(); s.setName("zhangsan"); s.setAge(18); Teacher t = new Teacher(); t.setName("aTai"); s.setAge(38); administrator a = new administrator(); a.setName("liumou"); a.setAge(30);
register(s); register(t); register(a); }
//这个方法技能接收老师,又能接收学生,还能接收管理员 //只能把参数写成这三个类型的父类 public static void register(Person p){ p.show(); } }
public class Test { public static void main(String[] args) { //创建对象(多态方式) //Fu f = new Zi(); Animal a = new Dog(); //调用成员变量:编译看左边 //编译看左边: javac 编译代码的时候,会看左边父类中有没有这个变量,如果有,编译成功,如果没有编译失败 //运行也看左边: java运行代码的时候,实际获取的就是左边父类中成员变量的值 System.out.println(a.name);
//调用成员方法:编译看左边.运行看右边 //编译看左边:javac编译代码的时候.会看左边的父类中有没有这个方法,如果有,编译成功.如果没有,编译失败. //运行看右边:java运行代码的时候,实际上运行的是子类中的方法 a.show(); //理解: //Animal a = new Dog(); //现在用a去调用变量和方法的呀? 是的 //而a 是Animal类型的,所以默认都会从Animal这个类中去找
//成员变量:在子类的对象中,会把父类的成员变量也继承下的.父: name 子: name //成员方法:如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。 } static class Animal{ String name = "动物"; public void show(){ System.out.println("Animal --- show方法"); } } static class Dog extends Animal{ String name = "狗"; public void show(){ System.out.println("Dog --- show方法"); } } static class Cat extends Animal{ String name = "猫"; public void show(){ System.out.println("Cat --- show方法"); } } }
@Override public void eat() { System.out.println("青蛙再吃虫子"); }
public Frog(String name, int age) { super(name, age); }
public Frog() { }
@Override public void swim() { System.out.println("青蛙在蛙泳"); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
子类兔子
package interfaceDemo1;
public class Rabbit extends Animal{
public Rabbit(String name, int age) { super(name, age); }
public Rabbit() { }
@Override public void eat() { System.out.println("兔子再吃胡萝卜"); } }
1 2 3 4 5 6 7
游泳接口: package interfaceDemo1;
public interface Swim { public abstract void swim(); }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
测试类: package interfaceDemo1;
public class Test { public static void main(String[] args) { //创建青蛙对象 Frog f = new Frog("GuaGua",1); System.out.println(f.getName() + ", " + f.getAge()); f.eat(); f.swim();
//创建兔子对象 Rabbit r = new Rabbit("xiaobai",3); System.out.println(r.getName() + ", " + r.getAge()); r.eat(); //r.swim; //会报错 } }
public class Car { private String carName; private int carAge; private String carColor;
public String getCarName() { return carName; }
public void setCarName(String carName) { this.carName = carName; }
public int getCarAge() { return carAge; }
public void setCarAge(int carAge) { this.carAge = carAge; }
public String getCarColor() { return carColor; }
public void setCarColor(String carColor) { this.carColor = carColor; }
public Car(String carName, int carAge, String carColor) { this.carName = carName; this.carAge = carAge; this.carColor = carColor; }
public Car() { }
public void show(){ System.out.println(carName); Engine e = new Engine();
System.out.println(e.engineName); } class Engine{ String engineName; int engineAge;
public void show(){ System.out.println(engineName); System.out.println(carName); } } }
内部类分类
成员内部类
静态内部类
局部内部类
匿名内部类
成员内部类
写在成员位置的,属于外部类的成员.
1 2 3 4 5 6 7 8 9
public class Car{ String carName; int carAge; int carColor; class Engine{ String engineName; int engineAge; } }
成员内部类可以被一些修饰符所修饰,比如: private, 默认(空着不写), protected(本包和其他包中的子类使用), public static等
在成员内部类里面,JDK16之前不能定义静态变量, JDK 16才开始可以定义静态变量
创建成员内部类的对象
方式一:
在外部类中编写方法,对外提供内部类的对象
方式二:
直接创建格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
范例: Outer.Inner oi = new Outer().new Inner();
成员内部类如何获取外部类的成员变量
对于变量名字不同的,直接用即可
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
package InclassDemo2;
public class Outer { private int a = 10; class Inner{ private int b =20; public void show (){ int c = 30; System.out.println(a);//要求打印10 System.out.println(b);//要求打印20 System.out.println(c);//要求打印30 } } }
对于变量名字相同的
1 2 3 4 5 6 7 8 9 10 11 12 13 14
package InclassDemo2;
public class Outer { private int a = 10; class Inner{ private int a =20; public void show (){ int a = 30; System.out.println(Outer.this.a);//要求打印10 System.out.println(this.a);//要求打印20 System.out.println(a);//要求打印30 } } }
静态内部类
静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建外部类的对象。
城建静态内部类对象的格式:
外部类名.内部类名 对象名 = new 外部类名.内部类名();
调用静态党发的格式:
外部类名.内部类名.方法名();
注意事项:
静态内部类也是成员内部类中的一种
静态内部类只能访问外部类中的静态变量和静态方法
Demo
1 2 3 4 5 6 7 8 9 10 11 12 13 14
package InnerClassDemo3;
public class Outer { int a = 10; static int b = 20; static class Inner{ public void show1(){ System.out.println("非静态的方法被调用了"); } public static void show2(){ System.out.println("静态的方法被调用了"); } } }
test类
1 2 3 4 5 6 7 8 9
package InnerClassDemo3;
public class Test { public static void main(String[] args) { Outer.Inner oi = new Outer.Inner(); oi.show1(); Outer.Inner.show2(); } }
public class Outer { int b = 20; public void show(){ int a = 10; class Inner{ String name; int age; public void method(){ System.out.println(b); System.out.println(a); System.out.println("局部有内部类中的method方法"); } public static void method2(){ System.out.println("局部有内部类中的method2静态方法"); }
} Inner i = new Inner(); System.out.println(i.name); System.out.println(i.age); i.method(); Inner.method2();
} }
1 2 3 4 5 6 7 8 9 10
package InnerClassDemo4;
public class Test { public static void main(String[] args) { Outer o = new Outer(); o.show(); } }
public class ObjectDemo1 { public static void main(String[] args) { //toString 返回对象的字符串表示形式 Object obj = new Object(); Object obj1 = new Object(); String str1 = obj.toString(); String str2 = obj1.toString(); System.out.println(str1);//java.lang.Object@4eec7777 "@"前是包名+类名 后面是对象的地址值 System.out.println(str2); //equals String s = "abc"; String b = "abc"; StringBuilder sb = new StringBuilder("abc"); StringBuilder sb2 = new StringBuilder("abc"); System.out.println(s.equals(b)); System.out.println(s.equals(sb)); //因为equals方法是被s调用的，而s是字符串所以equals要看string类中的 //字符串中的equals方法，先判断参数是否为字符串'如果是字符串，再比较内部的属性 //但是如果参数不是字符串，直接返回false System.out.println(sb.equals(s)); System.out.println(sb.equals(sb2)); ///因为equals方法是被sb调用的，而sb是stringBuilder所以这里的equals方法要看stringBuilder中的equals方法 // 那么在StringBuilder当中，没有重写equals方法 ///使用的是object中的 ///在object当中默认是使用==号比较两个对象的地址值 ///而这里的s和sb记录的地址值是不一样的，所以结果返回false } }
BigInteger
BigInteger常见构造方法
构造方法
说明
BigInteger(int num,Random rnd)
获取随机最大整数,范围[0 , 2的num次方 - 1]
BigInteger(String val) (字符串val必须是整数)
获取指定的大整数
BigInteger(String val , int radix)
获取指定进制的大整数
静态方法:public static BigInteger valueOf(long)
静态方法获取BigInteger的对象，内部有优化
BigInteger构造方法小结
如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
如果BigInteger表示的超出long的范围，可以用构造方法获取。
对象一旦创建，BigInteger内部记录的值不能发生改变。
只要进行计算都会产生一个新的BigInteger对象
Demo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
public class BigIntergerDemo1 { public static void main(String[] args) { //获取一个随机的大整数,范围[0 , 2的4次方-1] => [0, 15] BigInteger bi = new BigInteger(4,new Random()); System.out.println(bi);
//获取一个指定的大整数 BigInteger bi2 = new BigInteger("100000000000000000000"); System.out.println(bi2);
//获取指定进制的大整数 BigInteger bi3 = new BigInteger("100",10); // 十进制的100 System.out.println(bi3); BigInteger bi4 = new BigInteger("100",2); System.out.println(bi4);//将2进制的100转换成10进制的4并打印出来 } }
//intValue()转为int类型的整数,超出范围数据有误 int i = bi1.intValue(); System.out.println(i); // 10 BigInteger bi4 = BigInteger.valueOf(9999999999999999L); int i1 = bi4.intValue(); System.out.println(i1); // 1874919423 超出int类型范围,数据有误
//longValue()转为long类型的整数 long l = bi4.longValue(); System.out.println(l);// 9999999999999999 //doubleValue()转为double类型的小数 double v = bi1.doubleValue(); System.out.println(v); // 10.0
public class RegexDemo2 { public static void main(String[] args) { System.out.println("-------------1----------------"); //.表示一个任意字符 System.out.println("你".matches("."));//true System.out.println("你n".matches("."));//false System.out.println("你n".matches(".."));//true
public class RegexDemo3 { public static void main(String[] args) { System.out.println("a".matches("[abc]?"));//true 一次或0次 System.out.println("".matches("[abc]?"));//true
public class crawler { public static void main(String[] args) { /*有如下文本，请按照要求爬取数据。 Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是ava8和ava11， 因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台 要求:找出里面所有的JavaXX */ String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11," + "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
// method1(str);
//1.获取正则表达式的对象,也就是Pattern的对象 Pattern p = Pattern.compile("Java\\d{0,2}"); //2.获取文本匹配器的对象 Matcher m = p.matcher(str); //3.利用循环 while (m.find()){ String s = m.group(); System.out.println(s); }
public class crawlerTwo { public static void main(String[] args) { String s = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是java8和Java11," + "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
public class crawlerThree { public static void main(String[] args) { /*需求1∶按照ab+的方式爬取ab，b尽可能多获取 需求2:按照ab+的方式爬取ab，b尽可能少获取 */ String s ="Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" + "经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
//贪婪爬取 (Java默认) String regex = "ab+";
Pattern p = Pattern.compile(regex); Matcher m = p.matcher(s); while (m.find()){ System.out.println(m.group()); }
public class crawlerFour { public static void main(String[] args) { /*有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠 要求1:把字符串中三个姓名之间的字母替换为vs 要求2:把字符串中的三个姓名切割出来 */
public class SimpleDateFormatDemo1 { public static void main(String[] args) throws ParseException { //利用空参构造创建对象 SimpleDateFormat sdf1 = new SimpleDateFormat(); Date d1 = new Date(); System.out.println(sdf1.format(d1));
//利用带参的方式构造对象 SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 EE"); Date d2 = new Date(); System.out.println(sdf2.format(d2));
//定义一个字符串表示时间 String str = "2024-04-25 19:01:00"; SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date parse = sdf3.parse(str); System.out.println(parse); } }
Calendar c = Calendar.getInstance(); System.out.println(c);
//修改一下日历代表时间 Date d = new Date(0L); c.setTime(d); System.out.println(c); // c.set(1,2000); // 取消注释之后 下面年份变成2000 // c.set(2,2); //取消注释后 下面月份变成2 实际上是3月 // c.set(5,6); //取消注释后 下面日期变成 6
int Time = c.get(0); System.out.println(Time);//1 int year = c.get(1); System.out.println(year);//1970 int mon = c.get(2); System.out.println(mon);//0 实际上是 1月 int day = c.get(5); System.out.println(day); // 1 int yearweek = c.get(3); System.out.println(yearweek);//一年中第一周
c.add(1,20);//增加20年 year = c.get(1); System.out.println(year);
public class FileDemo1 { public static void main(String[] args) { /* public boolean isDirectory() //判断此路径名表示的File是否为文件夹 public boolean isFile() //判断此路径名表示的File是否为文件 public boolean exists() //判断此路径名表示的File是否存在 */ //对一个路径进行判断 File f1 = new File("D:\\javaprogram\\blackhorse\\idea\\basic-code\\myAPI\\awd\\src\\Main.java"); System.out.println(f1.isDirectory()); //false System.out.println(f1.isFile()); //true System.out.println(f1.exists()); //true
//对一个文件夹进行判断 File f2 = new File("D:\\javaprogram\\blackhorse\\idea\\basic-code\\myAPI\\awd\\src"); System.out.println(f2.isDirectory());//true System.out.println(f2.isFile());//false System.out.println(f2.exists());//true
public class FileDemo2 { public static void main(String[] args) { /* public long length() 返回文件的大小(字节数量) public string getAbsolutePath() 返回文件的绝对路径 public string getPath() 返回定义文件时使用的路径 public string getName( ) 返回文件的名称，带后缀 public long lastModified( ) 返回文件的最后修改时间(时间毫种值> */ File f1 = new File("D:\\javaprogram\\blackhorse\\idea\\basic-code\\myAPI\\File\\src\\FileDemo1.java"); System.out.println(f1.length()); //单位字节
//判断文件夹的大小 File f2 = new File("D:\\javaprogram\\blackhorse\\idea\\basic-code\\myAPI\\File\\src"); System.out.println(f2.length());//返回4096 结果不争取， length()方法无法获取文件夹的大小
public class FileDemo3 { public static void main(String[] args) throws IOException { /* public boolean createNewFile() 创建一个新的空的文件 public boolean mkdir() 创建单级文件夹 public boolean mkdirs( ) 创建多级文件夹 public boolean delete() 删除文件、空文件夹 */
File f1 = new File("D:\\javaprogram\\blackhorse\\idea\\basic-code\\myAPI\\File\\src\\FileDemo1.java"); System.out.println(f1.createNewFile()); //如果文件存在创建失败，返回false 如果文件不存在，创建成功， 返回true 如果 //如果父级路径不存在，也返回false 文件创建失败 //createNewFile()创建的一定是文件，如果不包含文件后缀名 则创建一个不含有后缀名的文件
wechat
