- JAVA入门
- 封装——四个访问控制符
- 多态
- 对象的转型
- 抽象方法_抽象类
- 接口的定义和实现
- String类常用方法
- 异常处理
- FileReader 读取文件异常处理
- JDK新特性_try-with-resource（自动关闭Closeable接口的资源）
- 包装类基本用法
- StringBuilder和StringBuffer用法
- 字符序列陷阱_时间和空间效率测试
- 使用StringBuilder进行字符串的拼接既高效又节省空间
- Date类用法
- DateFormat时间格式化类
- Math类和Random类
- File类的使用
- File类_递归_打印目录树结构
- 枚举_switch语句复习
- 容器
- 泛型类
- 泛型接口
- 泛型方法_非静态方法
- 泛型方法_静态方法
- 泛型方法与可变参数
- 无界通配符
- 统配符的上限限定
- 统配符的上限限定
- 泛型总结
- Java中的容器结构
package project02;
public class StringTest1 {
public static void main(String[] args) {
String s1 = "core Java";
String s2 = "Core Java";
System.out.println(s1.charAt(3)); //提取下标为3的字符
System.out.println(s2.length()); //字符串的长度
System.out.println(s1.equals(s2)); //比较两个字符串是否相等
System.out.println(s1.equalsIgnoreCase(s2)); //比较两个字符串（忽略大小写）
System.out.println(s1.indexOf("Java")); //字符串s1中是否包含Java 返回首次出现的位置
System.out.println(s1.indexOf("apple")); //字符串s1中是否包含apple
String s = s1.replace(' ','&'); //将s1中的空格替换成&
System.out.println("result is "+s);
}
}
package project02;
public class StringTest2 {
public static void main(String[] args) {
String s = "";
String s1 = "How are you?";
System.out.println(s1.startsWith("How")); //是否以How开头
System.out.println(s1.endsWith("you")); //是否以you结尾
s = s1.substring(4); //提取字符串：从下标为4开始到字符串结尾为止
System.out.println(s);
s = s1.substring(4,7); //提取字符串 [4,7) 不包括7
System.out.println(s);
s = s1.toLowerCase(); //全部转小写
System.out.println(s);
s = s1.toUpperCase(); //全部转大写
System.out.println(s);
String s2 = " How old are you! ";
s = s2.trim(); //去除字符串首尾的空格。 中间空格不能去除
System.out.println(s);
}
}
异常处理
FileReader 读取文件异常处理
package project03;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class test01 {
public static void main(String[] args) {
FileReader reader = null;
try {
reader = new FileReader("C:/Users/kangyi/Desktop/a.txt");
char[] cbuf =new char[1000];
int len = reader.read(cbuf);
System.out.println(new String(cbuf,0,len));
// reader = new FileReader("C:/Users/kangyi/Desktop/a.txt");
// char c = (char)reader.read();
// char c1 = (char)reader.read();
// char c2 = (char)reader.read();
// System.out.println("文本内容为:"+c+c1+c2);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(reader != null)
{
reader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
JDK新特性_try-with-resource（自动关闭Closeable接口的资源）
package project03;
import java.io.FileReader;
import java.io.IOException;
public class test03 {
public static void main(String[] args) {
try(FileReader reader = new FileReader("C:/Users/kangyi/Desktop/a.txt")){
char[] cbuf = new char[1000];
int len = reader.read(cbuf);
System.out.println(new String(cbuf,0,len));
}catch (IOException e){
e.printStackTrace();
}
}
}
包装类基本用法
package project03;
public class test04 {
public static void main(String[] args) {
Integer i = new Integer(50); //从Java9开始被废弃
Integer j = Integer.valueOf(10); //官方推荐
int a = j.intValue(); //把包装类对象转成基本数据类型
double b = j.doublevalue();
//把字符串转成数字
Integer m = Integer.valueOf("456");
}
}
StringBuilder和StringBuffer用法
package project03;
public class test05 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("abc");
// StringBuffer sb2 = new StringBuffer("abc");
// StringBuilder
StringBuilder sb1 = new StringBuilder();
for (int i =0;i<7;i++){
sb.append((char)('a' + i )); //追加单个字符
}
System.out.println(sb.toString()); //转换成String输出
sb.append(",I can sing my abc!"); // 追加字符串
System.out.println(sb.toString());
//StringBuffer,下面的方法同样适用于StringBuilder
StringBuffer sb3 = new StringBuffer("北京尚学堂");
sb3.insert(0,"爱").insert(0,"我"); //插入字符串
System.out.println(sb3);
sb3.delete(0,2); //删除字符串
System.out.println(sb3);
sb3.deleteCharAt(0).deleteCharAt(0); //删除某个字符
System.out.println(sb3.charAt(0)); //获取某个字符
System.out.println(sb3.reverse()); //字符串逆序
}
}
字符序列陷阱_时间和空间效率测试
使用StringBuilder进行字符串的拼接既高效又节省空间
package project03;
import java.sql.SQLOutput;
public class test06 {
public static void main(String[] args) {
//使用String进行字符串的拼接
String str = "abc";
long num1 = Runtime.getRuntime().freeMemory(); // 获取系统剩余内存空间
long time1 = System.currentTimeMillis(); //获取系统的当前时间
for(int i = 0;i<5000;i++){
str = str +i; //相当于产生了5000个对象
}
long num2 = Runtime.getRuntime().freeMemory();
long time2 = System.currentTimeMillis();
System.out.println(str.toString());
System.out.println("String占用内存:"+(num1-num2));
System.out.println("String占用时间:"+(time2-time1));
// 使用StringBuilder进行字符串的拼接
StringBuilder sb1 = new StringBuilder("abc");
long num3 = Runtime.getRuntime().freeMemory();
long time3 = System.currentTimeMillis();
for (int i = 0;i<5000;i++){
sb1.append(i);
}
long num4 = Runtime.getRuntime().freeMemory();
long time4 = System.currentTimeMillis();
System.out.println(str.toString());
System.out.println("String占用内存:"+(num3-num4));
System.out.println("String占用内存:"+(time4-time3));
}
}
结果：
package project03;
import java.util.Date;
public class test07 {
public static void main(String[] args) {
long time = System.currentTimeMillis();//获取当前计算机时间
System.out.println(time);
Date date1 = new Date();//new一个date，获取当前时间
System.out.println(date1);
System.out.println(date1.getTime());
Date date2 = new Date(-21L*365*24*3600*1000);//计算机基点时间为1970，(-21L*365*24*3600*1000)倒回1949年
System.out.println(date2);
System.out.println(date2.equals(date1));//比较时间是否相等
System.out.println(date2.before(date1));//比较两时间前后顺序
System.out.println(date2.after(date1));//
}
}
DateFormat时间格式化类
package project03;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//测试DateFormat时间格式化类
public class DateFormat {
public static void main(String[] args) throws ParseException {
//字符串转时间
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//new一个时间格式
String str = "2049-10-1 10:00:00";
Date guoqing100 = format.parse(str);
System.out.println(guoqing100.getTime()); //2516666400000
System.out.println(guoqing100); //Fri Oct 01 10:00:00 CST 2049
//时间转字符串
SimpleDateFormat format2 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
Date date2 = new Date(2344551651651L);
String date2Str = format2.format(date2);
System.out.println(date2Str); //2044年04月18日 08时20分51秒
//小妙招
Date now = new Date();
SimpleDateFormat f1 = new SimpleDateFormat("现在是今年的第D天，第w周。");
String str3 = f1.format(now);
System.out.println(str3); //现在是今年的第349天，第51周。
}
}
Math类和Random类
package project03;
//Math类
public class TestMath {
public static void main(String[] args) {
//取整相关 *** 作
System.out.println(Math.ceil(3.2)); //向上取整
System.out.println(Math.floor(3.2)); //向下取整
System.out.println(Math.round(3.2)); //四舍五入
System.out.println(Math.round(3.8));
//绝对值，开方，a的b次幂等 *** 作
System.out.println(Math.abs(-45)); //绝对值
System.out.println(Math.sqrt(64)); //开方
System.out.println(Math.pow(5,2)); //5的2次幂
System.out.println(Math.pow(2,5)); //2的5次幂
//Math类中常用的常量
System.out.println(Math.PI); //3.141592653589793
System.out.println(Math.E); //2.718281828459045
//随机数
System.out.println(Math.random()); //[0,1)
}
}
package project03;
import java.util.Random;
//Random类
public class TestRandom {
public static void main(String[] args) {
Random rand = new Random();
//随机生成[0,1)之间的double类型的数据
System.out.println(rand.nextDouble());
//随机生成int类型允许范围内的整型数据
System.out.println(rand.nextInt());
//随机生成[0,1)之间的float类型的数据
System.out.println(rand.nextFloat());
//随机生成false或者true
System.out.println(rand.nextBoolean());
//随机生成[0,10)之间的int类型的数据
System.out.println(rand.nextInt(10));
//随机生成[20,30)之间的int类型的数据
System.out.println(20+rand.nextInt(10));
//随机生成[20，30)之间的int类型的数据(此种方法计算较为复杂)
System.out.println(20+(int)(rand.nextDouble()*10));
}
}
File类的使用
package project03;
import java.io.File;
import java.io.IOException;
import java.util.Date;
// File类的用法
public class TestFile {
public static void main(String[] args) throws IOException {
System.out.println(System.getProperty("user.dir")); //获取当前文件位置
File f = new File("a.txt"); //相对路径:默认放到user.dir目录下面
f.createNewFile(); //创建文件
File f2 = new File("C:/Users/kangyi/b.txt"); //绝对路径
f2.createNewFile();
f2.delete(); //删除文件
System.out.println("File是否存在:"+f.exists());
System.out.println("File是否是目录:"+f.isDirectory());
System.out.println("File是否是文件:"+f.isFile());
System.out.println("File最后修改的时间:"+new Date(f.lastModified()));
System.out.println("File的大小:"+f.length());
File f3 = new File("C:/Users/kangyi/电影/华语/大陆");
boolean flag = f3.mkdir(); // 目录结构中有一个不存在，则不会创建整个目录树
System.out.println(flag); //创建失败
boolean flags = f3.mkdirs(); //目录结构中有一个不存在也没关系:创建整个目录树
System.out.println(flags); //创建成功
}
}
File类_递归_打印目录树结构
package project03;
import java.io.File;
//打印目录树，结合递归
public class PrintFileTree {
public static void main(String[] args) {
File f = new File(System.getProperty("user.dir"));
printFile(f,0);
}
static void printFile(File file,int level){
for (int i=0;i
枚举_switch语句复习
package project03;
import java.util.Random;
//测试枚举_switch语句复习
public class TestEnum {
public static void main(String[] args) {
System.out.println(jijie.spring);
System.out.println(Season.spring);
for(Season s:Season.values()){
System.out.println(s);
}
int a = new Random().nextInt(4); //生成0，1，2，3随机数
switch (Season.values()[a]){
case spring:
System.out.println("春天");
break;
case summer:
System.out.println("夏天");
break;
case autumn:
System.out.println("秋天");
break;
case winter:
System.out.println("冬天");
break;
}
}
//枚举
enum Season{
spring,summer,autumn,winter
}
//普通方法定义一个类
class jijie{
public static final int spring = 0;
public static final int summer = 1;
public static final int autumn = 2;
public static final int winter = 3;
}
}
容器
泛型类
package project04;
//泛型类
public class Generic {
private T flag;
public T getFlag() {
return this.flag;
}
public void setFlag(T flag) {
this.flag = flag;
}
}
package project04;
// 测试类
public class TestGeneric {
public static void main(String[] args) {
Generic generic = new Generic<>();
generic.setFlag("admin");
String flag = generic.getFlag();
System.out.println(flag);
Generic generic1 = new Generic<>();
generic1.setFlag(100);
Integer flag1 = generic1.getFlag();
System.out.println(flag1);
}
}
泛型接口
package project04;
//定义一个泛型接口
public interface Igeneric {
T getName(T name);
}
package project04;
//定义一个接口实现类
public class IgenericImpl implements Igeneric{
@Override
public String getName(String name) {
return name;
}
}
package project04;
//测试类
public class TestIgeneric {
public static void main(String[] args) {
IgenericImpl igeneric = new IgenericImpl();
String name = igeneric.getName("kangyi");
System.out.println(name);
Igeneric igeneric1 = new IgenericImpl();
String name1 = igeneric1.getName("kangkang");
System.out.println(name1);
}
}
泛型方法_非静态方法
非静态方法使用泛型有两种情况:
1.通过泛型类的泛型来使用
2.通过泛型方法的方式来使用泛型
package project04;
//泛型方法
public class MethodGeneric {
//定义一个无返回值的泛型方法
public void setName(T name){
System.out.println(name);
}
//定义一个有返回值的泛型方法
public T getName(T name){
return name;
}
}
package project04;
//泛型方法测试类
public class TestMethodGeneric {
public static void main(String[] args) {
MethodGeneric methodGeneric = new MethodGeneric();
methodGeneric.setName("kangyi");
methodGeneric.setName(123456);
MethodGeneric methodGeneric1 = new MethodGeneric();
String name = methodGeneric1.getName("kangkang");
Integer name1 = methodGeneric1.getName(123);
System.out.println(name);
System.out.println(name1);
}
}
泛型方法_静态方法
静态方法使用泛型的方式只有一个:即只能在静态方法上定义泛型
package project04;
//泛型方法
public class MethodGeneric {
//非静态方法
//定义一个无返回值的泛型方法
public void setName(T name){
System.out.println(name);
}
//定义一个有返回值的泛型方法
public T getName(T name){
return name;
}
//静态方法
public static void setFlag(T flag){
System.out.println(flag);
}
public static T getFlag(T flag){
return flag;
}
}
package project04;
public class TestStaticMethodGeneric {
public static void main(String[] args) {
MethodGeneric.setFlag("kangyi");
MethodGeneric.setFlag(123456);
String flag = MethodGeneric.getFlag("kangkang");
System.out.println(flag);
Integer flag1 = MethodGeneric.getFlag(123456);
System.out.println(flag1);
}
}
泛型方法与可变参数
package project04;
//泛型方法
public class MethodGeneric {
//非静态方法
//定义一个无返回值的泛型方法
public void setName(T name){
System.out.println(name);
}
//定义一个有返回值的泛型方法
public T getName(T name){
return name;
}
//静态方法
public static void setFlag(T flag){
System.out.println(flag);
}
public static T getFlag(T flag){
return flag;
}
//使用泛型定义一个可变参数的方法
public void method (T...args){
for (T t :args){
System.out.println(t);
}
}
}
package project04;
//测试泛型方法与可变参数
public class TestMethodGeneric01 {
public static void main(String[] args) {
MethodGeneric methodGeneric = new MethodGeneric();
String[] arr = new String[]{"a","b","c"};
Integer[] arr1 = new Integer[]{1,2,3};
methodGeneric.method(arr);
methodGeneric.method(arr1);
}
}
无界通配符
package project04;
//? 无界通配符(通配任何类型)
//使用通配符能对泛型是任何类型的Generic的对象中的值做输出
public class ShowMsg {
public void showFlag(Generic generic){
System.out.println(generic.getFlag());
}
}
package project04;
//测试通配符
public class TestShowMsg {
public static void main(String[] args) {
ShowMsg showMsg = new ShowMsg();
Generic generic = new Generic<>();
generic.setFlag(20);
showMsg.showFlag(generic);
Generic generic1 = new Generic<>();
generic1.setFlag(50);
showMsg.showFlag(generic1);
Generic generic2 = new Generic<>();
generic2.setFlag("kangyi");
showMsg.showFlag(generic2);
}
}
统配符的上限限定
统配符的上限限定
泛型总结
Java中的容器结构
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）