学习笔记——day13

最新推荐文章于 2019-10-08 21:16:22 发布

陈肉肉

最新推荐文章于 2019-10-08 21:16:22 发布

阅读量133

点赞数

分类专栏：学习笔记

本文链接：https://blog.csdn.net/Katherine_c/article/details/97153731

版权

学习笔记专栏收录该内容

31 篇文章 0 订阅

订阅专栏

在这里插入图片描述
异常：
NullPointerException 空指针异常

FileNotFoundException 系统没有找到指定文件异常

UnsupportedEncodingException 转码异常

*   main方法：
 *   	public：保证能够调用到
 *   	static：保证外界调用无需创建对象
 *   	void:   jvm无需返回值
 *   	String[] args： 可以传入  调用main方法时  可以传入实际参数
 * 
 */
public class Test01 {
	// dir       copy     md 
	public static void main(String[] args) {
		System.out.println("数组的长度："+args.length);
		//迭代 遍历
		for(String str:args) {
			System.out.println(str);
		}
		
		String order = args[0];
		
		switch(order) {
			case "copy":
					copy();
					break;
			case "dir":
					dir();
					break;
		}
		
		
	}
	
	public static void copy() {
		System.out.println("拷贝完成");
	}
	
	public static void dir() {
		// 获取当前路径
		//循环将所有的文件名称打印出来
	}
	
}

重写

package com.mage.ov;

import java.io.FileNotFoundException;

/**
 * 
 *   对于一个方法而言： 区分方法 通过方法名找方法  通过参数列表来确定方法
 *   方法重写：
 *   	发生继承关系、实现关系  父类不满足子类的需求  子类重写父类中的方法
 *   
 *   什么情况下会发生重写？
 *   	1：发生继承
 *   	2：方法名同名
 *   	3：参数列表要一模一样  (顺序 个数 类型)
 *   	4：子类的返回值类型<=父类的返回值类型(引用)  基本类型一模一样
 *   	5：子类的修饰符>=父类的修饰符  (父类中的修饰符不能是private)
 *   	6：子类抛出的异常<=父类抛出的异常  (理解：可以认为任意一个方法都会对外抛出运行时异常)
 *   	参一反小修大异小
 *   
 * @author wawjy
 *
 */
public class Test01 {
	public static void main(String[] args) {
		
	}
}
class F{
	F fun(F s) {
		System.out.println(1/0);
		return null;
	}
}
class S extends F{
	@Override
	public S fun(F s)throws NullPointerException{
		return null;
	}
}

package com.mage.scanner;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

/*
 *  学习使用Scanner
 * 		hasNextXXX   获取扫描到的数据是否是XXX类型
 * 		nextXXX      获取下一个扫描到的内容转为XXX类型(转换过程中有可能存在问题)
 */
public class Test01 {
	public static void main(String[] args)throws FileNotFoundException {
		Scanner input = new Scanner(System.in);
		/*
		 * if(input.hasNextInt()) { System.out.println(input.nextInt()); }
		 */
		if(input.hasNext()) {
			System.out.println(input.next());
		}
		
		//重新创建Scanner对象 指定文件作为输入源
		Scanner sc = new Scanner(new File("C:\\Users\\wawjy\\Desktop\\a.txt"));
		System.out.println(sc.next());
	}
}

String

创建String对象的方法：

String 构造器

String str1 = new String();

通过双引号直接创建String对象

String str2 = "love";

通过字符串常量给str3赋值

String str3 = "";

按照字节数组创建字符串对象

        byte[] buf = new byte[] {65,66,67,68,69};
		
		String str4 = new String(buf);
		System.out.println("通过字节数组创建字符串："+str4);
		
		//从buf 数组的索引为2的位置开始截取2个长度
		str4 = new String(buf,2,2);
		System.out.println("通过字节数组创建字符串："+str4);
		
		str4 = new String(buf,2,2,"UTF-8");
		System.out.println("通过字节数组创建字符串："+str4);

按照字符数组创建字符串对象

char[] ch = new char[] {'学','习','真','难'};
		str4 = new String(ch);
		System.out.println("通过字符数组创建字符串："+str4);
		
		str4 = new String(ch,0,2);
		System.out.println("通过字符数组创建字符串："+str4);

按照代码点创建字符串对象

        int[] ins = new int[] {88,89,100,99};
		str4 = new String(ins,0,4);
		System.out.println("按照代码点创建字符串对象："+str4);

按照字符串对象创建字符串对象

        String str5 = new String("abc");
		System.out.println(str5);

import java.io.UnsupportedEncodingException;

/**
 *   String：
 *   	  字符串： 一组字符序列    (不可变的串)
 *   	创建String对象：
 *   		new String();
 *   		new String("abc");
 *   		"love";
 *   		new String(buf,2,2);//通过字节数组创建
 *   	
 *   StringBuffer
 *   StringBuilder(jdk1.5之后才有的)
 * @author wawjy
 *
 */
public class Test01 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		
		// String 构造器
		String str1 = new String();//是一个""对象  空串没有值，null是还没有创建
		
		System.out.println(str1);
		
		
		// 通过双引号直接创建String对象
		String str2 = "love";//通过字符串常量直接创建String对象 
		//通过字符串常量给str3赋值
		String str3 = "";
		
		//比较str1和str3
		System.out.println(str1==str3);//比较的是地址
		
		
		//按照字节数组创建字符串对象
		byte[] buf = new byte[] {65,66,67,68,69};
		
		String str4 = new String(buf);
		System.out.println("通过字节数组创建字符串："+str4);
		//从buf 数组的索引为2的位置开始截取2个长度
		str4 = new String(buf,2,2);
		System.out.println("通过字节数组创建字符串："+str4);
		
		str4 = new String(buf,2,2,"UTF-8");
		System.out.println("通过字节数组创建字符串："+str4);
		
		
		//按照字符数组创建字符串对象
		char[] ch = new char[] {'学','习','真','难'};
		str4 = new String(ch);
		System.out.println("通过字符数组创建字符串："+str4);
		
		str4 = new String(ch,0,2);
		System.out.println("通过字符数组创建字符串："+str4);
		
		
		//按照代码点创建字符串对象
		int[] ins = new int[] {88,89,100,99};
		str4 = new String(ins,0,4);
		System.out.println("按照代码点创建字符串对象："+str4);
		
		//按照字符串对象创建字符串对象
		String str5 = new String("abc");
		System.out.println(str5);
		
	}
}



输出结果：
           //输出的是空格
false
通过字节数组创建字符串：ABCDE
通过字节数组创建字符串：CD
通过字节数组创建字符串：CD
通过字符数组创建字符串：学习真难
通过字符数组创建字符串：学习
按照代码点创建字符串对象：XYdc
abc

String的常见方法

charAt(int index); \ \ 返回当前索引位置上的指定字符
codePointAt(index); \ \ 返回指定索引位置上元素的代码点
compareTo(String); \ \ 比较两个字符串的大小
compareToIgnoreCase(String) \ \ 比较两个字符串的大小（忽略大小写）
concat(String) \ \ 拼接字符串
copyValueOf(char[]); \ \ 复制字符串
endsWith() \ \ 判断或查找格式
getBytes \ \ 字符
getChars()
indexOf 返回负数代表未找到
isEmpty 查看数组是否为空
repleace 替换
splite 截取
subString 截取
toUpperCase 大小写转换转为大写
toLowerCase(); 大小写转换转为小写
String str1 = String.valueOf(123); 通过静态方法创建String对象
//对象转字符串其实就是调用当前对象的toString方法

    User u = new User(10);
	String str2 = String.valueOf(u);

import java.util.Arrays;

/*
 *  String 的常见方法：
 *  	
 * 
 * 
 */
public class Test02 {
	public static void main(String[] args) {
		
		// 创建一个String对象
		String str = "ilovejavaandlaoxue";
		
		//charAt(int index);
		char ch = str.charAt(3);
		System.out.println("返回当前索引位置上的指定字符："+ch);
		
		//codePointAt(index)
		int num = str.codePointAt(0);
		System.out.println("返回指定索引位置上元素的代码点："+num);
		
		//compareTo(String)
		String cStr = "ilovejavaandlaoxu";
		num = str.compareTo(cStr);
		System.out.println("比较两个字符串的大小："+num);
		
		//compareToIgnronCase(String)
		cStr = "ILOVEJAVAANDLAOXUE";
		num = str.compareToIgnoreCase(cStr);
		System.out.println("比较两个字符串的大小（忽略大小写）："+num);
		
		//concat(String)
		cStr = "andgirl";
		str = str.concat(cStr);		
		System.out.println("拼接之后的结果是："+str);
		
		
		//copyValueOf(char[])
		char[] chs = new char[] {'i','l','o','v','e'};
		str = String.copyValueOf(chs);
		System.out.println("创建新的字符串："+str);
		
		str = String.copyValueOf(chs,1,4);
		System.out.println("创建新的字符串："+str);
		
		str = "憨憨.avi";
		boolean flag = str.endsWith(".avi");
		System.out.println("str是否是.avi格式："+flag);
		
		
		//getBytes
		byte[] buf = str.getBytes();
		System.out.println("获取字符串的字节数组："+Arrays.toString(buf));
		
		//getChars();
		chs = new char[10];
		//  从str的2索引处开始  到str的第6个索引结束(不包含)  复制到chs字符数组中 从第1个位置开始
		str.getChars(2,6, chs, 1);
		System.out.println("获取字符串的字符数组："+Arrays.toString(chs));
		
		
		//indexOf  返回负数代表未找到
		str = "hehe.avi.png";
		int index = str.indexOf(".");
		System.out.println(".在string中第一次出现的位置是："+index);
		
		index = str.indexOf(100);
		System.out.println("e在string中第一次出现的位置是："+index);
		
		index = str.indexOf(".",5);
		System.out.println(".在string中第5个索引位置开始计算，第一次出现的位置是："+index);
		
		
		
		index = str.lastIndexOf(".");
		System.out.println(".在string中最后一次出现的位置是："+index);
		
		
		//isEmpty()
		System.out.println("查看数组是否为null:"+str.isEmpty());
		
		//repleace
		str = "hehe.avi.png";
		str = str.replace(".", "+");
		System.out.println("替换之后的结果："+str);
		
		
		
		//splite:
		str = "login?unme=zs&pwd=zs";
		
		String[] strs = str.split("\\?");
		for(String string:strs) {
			System.out.println(string);
		}
		System.out.println("======");
		String parms = strs[1];
		strs = parms.split("&");
		for(String string:strs) {
			String[] ss = string.split("=");
			System.out.println(ss[1]);
		}
		
		
		//subString
		str = "login?unme=zs&pwd=zs";
		str = str.substring(4);// 从4索引开始截取到结束
		System.out.println("截取字符串："+str);
		
		str = str.substring(2, 7);//从2索引开始截取 到索引为7结束不包含7
		System.out.println("截取字符串："+str);
		
		
		
		//大小写转换
		str = "login?unme=zs&pwd=zs";
		str = str.toUpperCase();
		System.out.println("转为大写："+str);
		
		str = str.toLowerCase();
		System.out.println("转为小写："+str);
		
		
		//通过静态方法创建String对象
		String str1 = String.valueOf(123);
		System.out.println(str1);
		
		//对象转字符串 其实就是调用当前对象的toString方法
		User u = new User(10);
		String str2 = String.valueOf(u);
		System.out.println(str2);
		
		
		
	}
}

class User{
	private int age;
	public User() {
		// TODO Auto-generated constructor stub
	}
	public User(int age) {
		super();
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [age=" + age + "]";
	}
	
	
}

输出结果：
返回当前索引位置上的指定字符：v
返回指定索引位置上元素的代码点：105
比较两个字符串的大小：1
比较两个字符串的大小（忽略大小写）：0
拼接之后的结果是：ilovejavaandlaoxueandgirl
创建新的字符串：ilove
创建新的字符串：love
str是否是.avi格式：true
获取字符串的字节数组：[-70, -87, -70, -87, 46, 97, 118, 105]
获取字符串的字符数组：[

StringBuffer

可变，之所以能够可变的原因，底层就是一个字符数组，动态数组。

append
insert

public class Test04 {
	public static void main(String[] args) {
		// 创建StringBuffer
		StringBuffer sb = new StringBuffer();
		// 容量16
		System.out.println("通过空构造器创建的StringBuffer的容量："+sb.capacity());
		
		
		//添加元素
		sb.append(true);
		
		sb.append(false).append("123").append("134");// 链式编程
		
		
		System.out.println(sb);
		System.out.println("当前sb对象中的字符串长度："+sb.length());
		
		//添加元素
		sb.insert(1, "heihei");
		System.out.println(sb);
		
	}
}

StringBuild

StringBuilder和StringBuffer 都继承了AbstractStringBuilder

StringBuffer效率低于StringBuilder
StringBuffer安全性要高于StringBuilder
一般情况下使用StringBuilder
jdk9之后 String中存储数据通过byte数组存储 + 变量
jdk中对于String存储时的内容消耗极大降低

public class Test05 {
	public static void main(String[] args) {
		
		// StringBuilder
		StringBuilder sb = new StringBuilder();//构建16个长度的字符数组
		
		//添加元素
		sb.append("学习难了");
		sb.insert(2, "老鼻子");
		
		System.out.println(sb);
		
		
	}
}

包装类：

8大基本数据类型 -> 8个包装类

 byte->Byte
 short->Short
 char ->Character
 int  ->Integer
 long ->Long
 float->Float
 double->Double
 boolean->Boolean

jdk12 Integer中的所有构造器都过时通过valueOf方法获取int对应的Integer对象
String->int Integer.parseInt();// 可能报异常
int ->String String.valueOf()

public class Test01 {
	public static void main(String[] args) {

		// 静态成员变量
		System.out.println("BYTES:" + Integer.BYTES);
		System.out.println("MAXVALUE:" + Integer.MAX_VALUE);
		System.out.println("MINVALUE:" + Integer.MIN_VALUE);
		System.out.println("SIZE" + Integer.SIZE);
		System.out.println("CLASS:" + Integer.TYPE);

		// 构造器
		Integer i1 = new Integer(12);
		System.out.println(i1);

		Integer i2 = new Integer("123");// 可能出现数字格式化异常
		System.out.println(i2);

		System.out.println(Integer.max(12, 12));

		// parseInt(String)字符串转换为int
		System.out.println("字符串转换为int" + Integer.parseInt("212"));
		// 将一个对应进制的数转换为十进制
		System.out.println("字符串转换为int" + Integer.parseInt("1100", 2));
		// 将当前数值在计算机中存储的补码进行翻转得到的十进制的数
		System.out.println("" + Integer.reverse(Integer.MAX_VALUE));

		System.out.println("2进制：" + Integer.toBinaryString(12));
		System.out.println("8进制：" + Integer.toOctalString(12));

		// 获取Integer对象
		Integer i3 = Integer.valueOf(12);
		System.out.println(i3);

		Integer i4 = Integer.valueOf("12");
		System.out.println(i4);
		System.out.println(Integer.class);
		System.out.println(Integer.decode("12"));
	}
}

/**
 * 
 * @author wawjy
 *  jdk1.5之后支持自动拆装箱，本质上就是调用了 
 *  		装箱：Integer.valueOf()
 *  		拆箱：对象.intValue()
 *  
 * 	 自动装箱时，首先会判定当前的值是否在缓冲区中[-128,127],如果在该区间中，直接从缓冲区中获取对应的Integer对象
 *  	反之会重新创建一个新的Integer对象
 */
public class Test02 {
	public static void main(String[] args) {
		Integer i1 = 123;//jdk1.5之后支持自动装箱 Integer.valueOf(123)
		int num = i1;//jdk1.5之后支持自动拆箱 i1.intValue()
		
		Integer i2 = 98;
		Integer i3 = 98;
		System.out.println(i2==i3);
		
		i2 = 128;
		i3= 128;
		System.out.println(i2==i3);
	}
}

/*
 * 
 *    字面值创建Boolean对象时 只能指定true和false 并且创建的对象也是对应的true和false
 *    字符串创建Boolean对象是 只要字符是true/false 无所谓大小写 得到对应的Boolean对象就是与之对应的true和false
 *    其它所有字符串赋值都是false
 * 
 * 
 */
public class Test03 {
	public static void main(String[] args) {
		//创建Boolean对象
		Boolean b1 = new Boolean("true");
		System.out.println(b1);
		
		b1 = new Boolean("false");
		System.out.println(b1);
		
		b1 = new Boolean("2");
		System.out.println(b1);
		
		b1 = new Boolean("TRue");
		System.out.println(b1);
		
		b1 = new Boolean("HJa");
		System.out.println(b1);
		
		b1 = new Boolean("FALSE");
		System.out.println(b1);
	}
}

Date

import java.util.Date;

/*
 * 
 *   和时间有关的类
 * 			Date:
 * 				空构造器对象创建出的是当前系统时间对象
 * 
 */
public class Test01 {
	public static void main(String[] args) {
		
		
		//创建Date对象
		Date d = new Date();
		System.out.println(d);//空构造器对象创建出的是当前系统时间对象
		
		//通过带参构造器创建对象
		Date d1 = new Date(3600);//参数代表毫秒数
		System.out.println(d1);//此时间为1970年加上系统设置的时区再加上参数
		
		System.out.println(d.after(d1));
		System.out.println(d.before(d1));
		
		//获取毫秒数
		Long dateTime = System.currentTimeMillis();
		System.out.println(dateTime);
		
	}
}

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test02 {
	public static void main(String[] args) {
		
		
		//创建时间对象
		Date d = new Date();
		
		//创建SImpleDateFormat对象
		SimpleDateFormat sd = new SimpleDateFormat();
		
		//设置想要输出的内容格式
		sd.applyPattern("yyyy年MM月dd日HH时mm分ss秒 是一年中的第D天 W w");
		
		//调用格式化方法格式化日期
		String str = sd.format(d);
		System.out.println(str);
		
		//创建对象并且指定格式化内容
		SimpleDateFormat  sd2 = new SimpleDateFormat("yy/MM/dd hh:mm:ss");
		System.out.println(sd2.format(d));
		
	}
}

import java.util.Objects;

/*
 * isNull:判定对象是否为null
 * toString：输出对象的
 * requireNonNull 判定对象是否为null 如果是null则抛出空指针异常不是null就打印相应的值
 */
public class Test01 {
	public static void main(String[] args) {
		String str = null;
		//System.out.println(str.toString());
		
		if(!Objects.isNull(str)) {
			System.out.println(str.toString());
		}
		
		System.out.println(Objects.toString(str));
		
		foo(str);
	}

	private static void foo(String str) {
		System.out.println(Objects.requireNonNull(str));
	}
}