Java知识点详解——第六章：包和String类型

包

Packet：用来分类管理类文件，包相当于文件夹，类相当于文件。

包的作用 ：

1. 解决命名冲突；
2. 分类存储便于管理代码；
3. 提高代码的安全性。

包的命名规范 ：

1. 全部使用小写字母；
2. 使用公司域名、项目名、模板名(包就是文件夹，用于存放源码文件);
3. 使用“.”对包名进行分割；
4. 包名首尾不能写“.”(“.”的作用用于对文件夹进行分层);
5. 包的创建应写在第一句。

        默认情况下编写Java代码使用的包环境是java.lang，因此使用其包中的内容不需要导入，可直接使用；如果使用java.lang以外的包的类型，则必须根据该类型所在的包进行import导入，导入方式：import 包名。

访问修饰符
        default，public，protected，private：用于修饰类、方法、变量。
        static：静态的，static修饰的数据表示常驻内存，当程序启动时，可通过“类名.方法名”进行访问。static修饰的数据表示常驻内存，当程序启动时，使用static修饰的方法，变量将直接在内存中构建，可通过“类名.方法名|属性名”访问静态的内容，因此使用static修饰的方法又称为类方法。
        final：修饰的变量称为常量，修饰的类不能被继承，修饰的方法不能被重写。

关键字	名称	功能	示例
	默认访问修饰符	没有访问修饰符，相当于protected的访问范围	int a
public	公共访问修饰符	在项目全局都能访问	public int b
protected	保护访问修饰符	只能在当前包中访问，并允许在子类访问	protected int c
private	私有访问修饰符	只能在当前类中访问	private int d

字符串

        字符串就是一串字符，任何一句话我们都能理解成是一个字符串。
        Object类是Java中的对象类，Java所有其他类都继承自Object(所有Java类都衍生自Object类)。

字符串的常用方法：

方法名	返回值	作用
length(String)	int	获取字符串的长度(空格也是字符)
equals(String)	boolean	比较值是否相同
equalsIgnoreCase(String)	boolean	比较值是否相同(忽略大小写)
toUpperCase(String)	String	将字符串转换成大写
toLowerCase(String)	String	将字符串转换成小写

获取字符串中字符的位置：

方法名	返回值	作用
indexOf(String)	int	获取字符第一次出现在字符串中的位置，从0开始，如果检索的数据不存在则返回-1
indexOf(String,int)	int	获取字符在指定位置起出现在字符串中的位置，int表示搜索字符串的起始索引
lastIndexOf(String)	int	获取字符在字符串中最后一次出现的位置
chatAt(int)	char	获取指定位置对应的字符

        注：判断某字符是否只出现一次，即判断该字符第一次出现的位置indexOf()和最后一次出现的位置lastIndexOf()是否相同即可。

截取字符串：

方法名	返回值	作用
subString(int)	String	从指定位置截取到字符串末尾
subString(int,int)	String	从指定位置截取到另一个指定位置的字符串。第一个参数表示截取的起始索引，第二个参数表示截取的结束索引(不包含该索引的字符)，返回起始索引与结束索引之间的字符串
replace(‘String’,‘String’)	String	替换字符串中的内容。第一个参数表示被替换的字符，第二个参数表示替换的新字符
replaceAll(“String”,“String”)	String	对字符串进行替换，并可以在第一参数中通过正则表达式进行检索替换
trim(String)	String	去除字符串中的首尾字符
reverse(String)	String	反转字符

字符串常用方法的示例：

import java.io.BufferedReader;

public class Demo{
	public void method(){}
	
	/**方法的重载 */
	public void method(int i){}

	/**字符串的常用方法 */
	public static void main(String[] args) {

		//length方法用于获取字符串的长度,空格也是字符
		String s = "hello     ";
		int len = s.length();
		System.out.println(len);
		
		//equals方法用于比较值是否相同
		String s1 = "java";
		String s2 = "JAVA";
		boolean flag = s1.equals(s2);
		System.out.println(flag);
		
		//忽略大小写比较
		System.out.println(s1.equalsIgnoreCase(s2));
		
		//将字符串转换成大写
		s1 = s1.toUpperCase();
		System.out.println(s1);
		//将字符串转换成小写
		s2 = s2.toLowerCase();
		System.out.println(s2);
		
		String s = "HelloTionsChiang";
		//indexOf方法用于从左往右检索某个字符串在源字符串中的索引位置,每一个都有对应的索引，从0开始
		//如果检索的数据不存在则返回-1
		int index = s.indexOf("Chiang");
		int index = s.indexOf("i");
		
		//从指定索引位置进行检索  第二个参数表示搜索字符串的起始索引
		int index = s.indexOf("i",5);
		//检索第2个i位置
		int index = s.indexOf("i",s.indexOf("i")+1);
		System.out.println(index);
		
		//从右往左检索字符串出现的索引位置
		int index = s.lastIndexOf("i");
		System.out.println(index);
		
		//根据索引位置获取对应的字符  参数范围是0~(length-1)
		char ch = s.charAt(0);
		System.out.println(ch);
		
		//遍历获取字符串中的每一个字符
		for(int i = 0; i < s.length(); i++){
			System.out.println(s.charAt(i));
		}
		
		//截取字符串
		//传一个参数表示从截取的位置截到字符串最后
		s = s.substring(4);
		//第一个参数表示截取的起始索引，第二个参数表示截取的结束索引（不包含该索引的字符），返回起始索引与结束索引间的字符串
		s = s.substring(5, 9);
		System.out.println(s);
		
		//替换字符串中的内容  第一个参数表示被替换的字符，第二个参数表示替换的新字符
		s = s.replace('n', 'm');
		System.out.println(s);
		
		//允许对字符串进行替换，并可以在第一参数中通过正则表达式进行检索替换
		s = s.replaceAll("Hello", "Wellcome");
		System.out.println(s);
		
		//拼接字符串
		String s1 = "hello";
		String s2 = "tionschiang";
		String s3 = s1.concat(s2);
		//等价于如下代码
		String s3 = s1+s2;
		System.out.println(s3);
		
		
		//去除字符串首尾空格
		String s1 = " Hello    ";
		System.out.println(s1.length());
		s2 = s1.trim();
		System.out.println(s2.length());
	}
}

日期类型的访问：
java.util.Date类型

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

public class Demo {

	/**日期类型的访问*/
	public static void main(String[] args) {
		//java.util.Date类型
		//获取当前操作系统的时间
		Date date = new Date();
		//打印本地时间
		System.out.println(date.toLocaleString());
		//对时间进行格式化
		SimpleDateFormat formater = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		String time = formater.format(date);
		System.out.println(time);
		
		//获取时间中的单位
		//月份	0-11对应一年中的十二个月
		int month = date.getMonth();
		//星期数  0表示星期天
		int day = date.getDay();
		//天
		int day = date.getDate();
		//小时
		int hour = date.getHours();
		//获取1970-1-1至今的毫秒数，主要用于Date类型和其他日期类型进行转换
		long dateTime = date.getTime();
		System.out.println(dateTime);
		System.out.println(date);
		
		//创建一个晚于当前时间1毫秒的时间
		Date date2 = new Date(date.getTime()+1);
		
		/**************根据毫秒值判断时间************/
		//判断时间早于被比较的时间
		System.out.println(date.before(date2));
		//判断时间晚于被比较的时间
		System.out.println(date.after(date2));
		//比较时间   1表示比被比较的时间晚   0表示两个相同  -1表示比被比较的时间早
		System.out.println(date.compareTo(date2));
		
		//日历类型  获取系统时间
		Calendar calendar = Calendar.getInstance();
		
		//设置新的时间  第一个参数表示设置的时间单位，第二个参数表示时间的值
		calendar.set(Calendar.YEAR, 2020);
		calendar.set(Calendar.MONTH, 2);
		calendar.set(calendar.DATE, 28);
		
		calendar.get(Calendar.YEAR);
		
		//添加时间单位的值
		calendar.add(Calendar.YEAR, -1);
		
		//将calendar类型转换成Date类型
		Date date = new Date(calendar.getTimeInMillis());
		SimpleDateFormat fomater = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		System.out.println(fomater.format(date));
		
		//捕获异常
		try {
			//将指定格式的字符串转换成Date类型
			date = fomater.parse("2010-05-1 15:00:00");
			System.out.println(date);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println();	
	}
}

StringBuffer & StringBuilder：
        String类的拼接每次都会产生一个新的字符串，因此在进行大量的拼接的场景时性能非常差，通过StringBuffer或者StringBuilder实现。
        String中的值是没法更改的，StringBuffer的值是可扩充可修改的。
        StringBuffer或者StringBuilder的区别在于StringBuffer是线程安全，StringBuilder是非线程安全。

public class Demo{
	/**StringBuffer & StringBuilder类型*/
	public static void main(String[] args) {
		
		//StringBuffer也称为增强型字符串
		StringBuffer buffer = new StringBuffer("hello");
		System.out.println(buffer);
		
		//将StringBuffer转换成String
		String s = buffer.toString();
		//将Striing转换成StringBuffer
		String s = "hello";
		StringBuffer buffer = new StringBuffer(s);
		System.out.println(buffer);
		
		StringBuffer buffer = new StringBuffer("hello");
		//追加字符数据 ，该方法不会产生新值，因此有着优异的性能
		buffer.append("chiang");
		System.out.println(buffer);
		//反转字符
		buffer.reverse();
		System.out.println(buffer);
		
		StringBuilder builder = new StringBuilder("hello");
		builder.append("tions").append("chiang");
		System.out.println(builder);
	}
}

验证邮箱名是否合法：

import java.util.Scanner;

public class Demo{
	
	/**验证邮箱 */
	public boolean validateEmail(String email){
		
		//第一次出现@的位置
		int a = email.indexOf("@");
		//第一次出现.的位置
		int b = email.indexOf(".");
		//邮箱的长度
		int len = email.length();
		
		//邮箱必须要包含.和@
		if(a == -1 || b == -1){
			System.out.println("邮箱必须要包含@和.");
			return false;
		}
		//@只能出现一次  （第一次出现的位置如果和最后出现的位置不同，则表示出现了多次）
		if(a != email.lastIndexOf("@")){
			System.out.println("@只能出现一次");
			return false;
		}
		//.和@不能在首尾位置
		if(a == 0 || a == len-1 || b == 0 || email.lastIndexOf(".") == len-1){
			System.out.println("@和.不能在首尾");
			return false;
		}
		//@要出现在.的前面
		if(b < a){
			System.out.println(".不能在@的前面");
			return false;
		}
		//@和.不能相邻
		if(email.indexOf("@.") != -1){
			System.out.println("@不能和.相邻");
			return false;
		}
		//.和.不能相邻
		if(email.indexOf("..") != -1){
			System.out.println(".和.不能相邻");
			return false;
		}
		return true;
	}
	
	/** 使用字符串的方法判断邮箱是否合法 */
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入要验证的邮箱：");
		String email = sc.next();
		Demo demo = new Demo();
		//验证邮箱
		demo.validateEmail(email);	
	}
}

注：
“==”用于判断两个变量是否相同，是根据要比较的对象进行比较；
“==”的使用场景：比较基本类型，比较是否是相同的对象。