Java包（访问修饰符的范围）String字符串StringBuilder类基本类型和引用类型

Posted 2021-02-21 陶汐儿sunny

包：是Java对类进行组织管理、划分类命名空间的机制，解决类名冲突问题

包的优点：

　　分类管理类，便于类的查找与使用

　　通过访问修饰符，可以对数据安全性进行管理

包名：纯小写（域名.项目名.模块名······）点代表文件夹分层，每个点分开的都是文件夹，系统会自动生成

包的声明：new——package

包的使用：

　　Java默认情况下访问Java.lang包中的数据

　　访问Java.lang包以外的数据需要导入该包

　　使用import包名.*导入包中所有数据

　　使用import包名.类名导入保重指定的类型

访问修饰符的范围：

　　默认不加任何修饰符是当前包中可以访问

　　public 表示项目中所有地方都能访问

　　protected 表示当前包和子类（不管在不在本包中）中都能访问

　　private 表示仅在当前类中

 

a包中要调用b包中的数据

a包中

packa com.igeek.a;
import com.igeek.b.ClassB;
public class ClassA{
　　public void methodA(){
　　　　//将B类进行实例化，因为B类在b包中，所以要导入
　　　　ClassB classB=new ClassB();
　　　　//调用classB对象中的methodB
　　　　classB.methodB();
　　}
}

b包中

package com.igeek.b;
　　public class Class{
　　int a;//默认
　　public int b;//public在项目中都能访问
　　protected int c;//protected在当前包中和子类都允许访问
　　pricate int d;//private 仅在当前类中允许访问
　　　　public void methodB(){
　　}
}

 

String字符串：

String类型：字符串是由多个单字符构成的类型

public void Demo{
　　public static void main(String[] args){
　　　　//直接创建字符串
　　　　String s1="hellogeekhome";
　　　　//创建对象的方式创建字符串
　　　　String s2=new String("hellogeekhome");
　　　　//字符串连接的方式创建字符串
　　　　String s3="hello"+"geekhome";
　　　　//和S2同样的方式
　　　　String s4=new String("hellogeekhome");

　　　　//进行比较
　　　　System.out.println(s1==s2);
　　　　System.out.println(s1==s3);
　　　　System.out.println(s2==s3);
　　　　System.out.println(s2==s4);
　　}
}

s1和s3都是方法区中常量池内的值，s2和s4都是在堆中创建出来的对象

==对比的是地址，所以只要地址不同，字符串比较的结果就是错误的

s1==s2：fault，因为1是在方法区中，2实在堆中
s1==s3：true，因为1和3都是常量池中的数据，且字符串就是单个字符连接的，所以即使是连接的方式创建字符串地址也是相同的
s2==s3：fault，和1与3比较的原因相同
s2==s4：fault，虽然两者都是通过创建对象的方法进行创建字符串，且都是存储在堆中，但是每次创建新对象结果都是不同的，所以对象的地址是不同的

 获得字符串的长度：length()　　返回值为int

判断字符串是否相等：equals()　　返回值为boolean

　　　　　　　　　　equalsIgnoreCase()    不区分大小写，返回值为boolean

统一字符大小写：

　　统一大写：toLowerCase

　　统一小写：toUpperCase

判断字符是否相同的例子

 

String course1="Java"；
Stringcourse2="JAVA"；
//直接进行比较会因为大小写得到结果为false
course1.equals(course2)
//用忽略大小写的方法得到结果为true
course1.equalsIgnoreCase(course2)
//将两个字符都进行统一大小写得到结果为true
course1=course1.toLowerCase;
course2=course2.toLowerCase;
course1.equals(course2)

 

判断字符串是否以指定内容开头：startWith(String)　　返回值为boolean

判断字符串是否以指定内容结尾：endsWith(String)　　返回值为boolean

prefix参数中的字符串在将来可以写入正则表达式规则

字符串检索的相关方法：

　　indexOf(String)：检索内容在源字符串的索引位置（只会查到第一个出现改内容的位置）

　　indexOf(String，int)：从指定索引检索内容在源字符串中索引位置

　　lastIndexOf(String)：从源字符串末端检索内容的索引（该索引还是从前往后开始数的）

　　charAt(int)：检索指定索引对应的字符

字符串修改的相关方法：

　　subString(int)：从指定位置截取至随后

　　subString(int，int)：从起始索引截取至结束索引　　//结束的索引都是至截取到这个位置为止，不包含该索引

　　trim：去除字符串首尾的空格

　　replaceAll(String，String)：对字符串内容进行替换（第一个参数是需要替换的，第二个是要替换成的内容）

通过索引查询字符，通过字符查找索引

String s="hellogeekhome";
//结果是8
int index=s.indexOf("k");
//结果是0
int index=s.indexOf("h");
//结果是6：因为查的位置是在源字符串中的位置
int index2=s.indexOf("e",3);
//结果是9
int index3=s.lastIndexOf("h");
//结果是G
char ch=s.charAt(5);

将字符串的字符一个个打印出来

for(int i=0;i<s.length;i++){
　　System.out.println(s.charAt(i));
}

验证输入的用户名只能由字母构成

Scanner sc=new Scanner(System.in);
Sys.out.println("请输入用户名：");
String name=sc.next();
for(int i=0;i<name.length();i++){
　　char ch=name.charAt(i);
　　//a=97,z=122;A=65,B=90
　　if(!(ch>=\'a\'&&ch<=\'z\')||!(ch>=\'A\'&&ch<=\'Z\')){
　　　　System.out.println("用户名输入非法，只能由字母构成！")
　　}
}

截取字符串

String s="helloGeekhome";
//得到Geekhome
s=s.subString(5);
//得到loG
s.subString(3，6)；

输入一个邮箱地址，如[e-mail]，要求打印显示邮箱用户名和邮箱类型

String email="[e-mail]";
//截取名字，同时确定位置并截取，截取到@不包括此索引
String name=email.subString(0，email.indexOf("@"));
//截取邮箱类型，从@符的后一位开始截取，截至最后一位
String emailaName=email.subString(email.indexOf("@")+1)

例子：编写一个方法用来判断字符串(source)中是否多次出现所查的字符串(searchStr)

两种方法：

　　方法一：第二次查找是从第一次查找到的地方进行查找

　　方法二：分别从头、从尾开始查找

//查找是否出现第二次的方法
public boolean validateDouble(String source,String searchStr){
　　//查找有没有出现第一次
　　int index=source.indexOf(searchStr);
　　//如果出现了第一次则再查第二次
　　if(index!=-1){
　　　　//source.indexOf(searchStr，index+1)!=-1表示查找到了第二次
　　　　//第二次从第一次查找到的索引的后一位开始查找
　　　　if(source.indexOf(searchStr，index+1)!=-1){
　　　　　　//如果出现第二次
　　　　　　return true;
　　　　}
　　}
　　//如果没有出现第二次
　　return false;
}

//查找是否出现第二次的方法
public boolean validateDouble(String source,String searchStr){
　　//从头开始查找第一次出现的位置
　　int index=source.indexOf(searchStr);
　　//从尾开始查找第一次出现的位置
　　int index1=source.lastIndexOf(searchStr)
　　//如果从头和从尾查到的位置是一样的，则只出现了一次
　　if(index==index1){
　　　　return false;
　　}
　　//如果从头和从尾查到的位置不一样，则出现了至少两次
　　else{
　　　　return true;
　　}
}

StringBuilder类：是一个可变的字符串

StringBuilder的值将会再缓冲区内进行修改

StringBuilder与String的方法几乎相同（不同的地方就在StringBuilder能够对字符串进行修改：追加、插入、删除、替换）

StringBuilder与String可相互转换

StringBuilder是非线程安全（非线程安全性能较高）

StringBuffer是线程安全（线程安全性能较低）

创建StringBuilder：创建StringBuilder的过程就是将字符串转换成StringBuilder的过程

StringBuilder str=new StringBuilder(String);

public static void main(System[] args){
　　//创建StringBuilder
　　StringBuilder str=new StringBuilder("hello");
　　System.out.peintln(str);
}

StringBuilder的toString()方法可以转换为String，java中的所有类型都可以通过toString()方法转换成字符串

String s=str.toString();

StringBuilder和String不同的方法：

追加内容：str.append(string);

插入内容：str.insert(index，string);

删除内容：str.delete(startIndex，endIndex);

根据指定的索引范围替换内容：str.replace(startIndex，endIndex，str);

StringBuilder str=new StringBuilder("hello");
//再末尾添加新字符串
//hellogeekhome
str.append("geekhome");
//第一个参数表示插入的位置，第二个参数表示插入的内容
//hXellogeekhome
str.insert(1,"X");
//第一个参数表示删除开始的位置，第二个参数表示删除结束的位置，不包含该索引自身
//hllogeekhome
str.delete(1,3);
//第一个参数是替换开始的位置，第二个参数是替换结束的位置（不包含该位置），第三个参数是需要替换成的内容
//abclogeekhome
str.replace(0,2,"abc");

基本类型和引用类型的区别：

1.基本类型再传递时，传递的是对应的值，当传入的基本类型再方法中修改值时，是不会对原变量的值造成影响的

2.引用类型再传递时，传递的是其对象地址，因此再方法中对传入的引用类型数据进行变更时，将会对原数据造成影响

 例子：

User类

public class User{
　　String name="tom";
}

带有方法的Demo类

public class Demo{
　　public void method1(int a,int b){
　　　　int c=a;
　　　　a=b;
　　　　b=c;
　　}
　　public void method2(User user){
　　　　user.name="jack";
　　}
　　public void method3(StringBuilder a,StringBuilder b,StringBuilder c){
　　　　//将a原值添加了A（a=AA;b=B;c=C）
　　　　a.append("A");
　　　　//将b换了个新对象，原b对象不动（a=AA;b=B;新的b=BB;c=C）
　　　　b=new StringBuilder("BB");
　　　　//将新对象添加了B（a=AA;b=B;新的b=BBB;c=C）
　　　　b.append("B");
　　　　//将C重新换了指定的新对象，原c对象不动（a=AA;b=B;新的b=BBB;c=AA）
　　　　c=a;
　　　　//c现在指定的是a所以是将a添加了C（a=AAC;b=B;新的b=BBB;c=AAC）
　　　　c.append("C");
　　}
}

调用方法：

public static void main(System[] args){
　　Demo demo=new Demo();
　　int a=10,b=20;
　　demo.method(a.b);
　　//打印出来a=10，b=20，虽然调用了方法，但是原值不变
　　System.out.println("a是"+a+"b是"+b);

　　User user=new User();
　　System.out.println("修改前名字是："+user.name);
　　demo.method2(user);
　　//调用方法后类user类进行修改，姓名原值就发生了改变
　　System.out.println("修改后名字是："+user.name);

　　//对abc通过调用方法进行修改
　　StringBuilder a=new StringBuilder("A");
　　StringBuilder b=new StringBuilder("B");
　　StringBuilder c=new StringBuilder("C");
　　demo.method3(a,b,c);
　　System.out.println(a);
　　System.out.println(b);
　　System.out.println(c);
}