1.Object类
1.“==”与“equals”的区别
运算符在比较基本数据类型时候,就是比较的值是否相同
在比较引用数据类型的时候,比较的是地址值是否相同
equals运算符只能比较引用数据类型,且默认情况下也是比较的地址是否相同
如果比较两个引用的里面的基本数据类型,则需要重写equals方法
public class Test {
public static void main(String[] args) {
Studen lisi = new Studen(20, "lisi");
Studen lisi2=new Studen(20,"lisi");
Studen zhaoliu = new Studen(30, "zhaoliu");
System.out.println(lisi.equals(zhaoliu));
System.out.println(lisi.equals(lisi2));
重写equals方法
public class Studen {
private int age;
public int getAge() {
return age;
}
public Studen(int age, String name) {
this.age = age;
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private String name;
@Override
public boolean equals(Object obj){
if (this==obj){
return true;
}
if (!(obj instanceof Studen)){
return false;
}
Studen s2=(Studen) obj;
return age==s2.age&&name.equals(s2.name);
}
}
public class Test {
public static void main(String[] args) {
// API:应用程序接口
Object o = new Object();//该包下的类不需要导包
// Object类中常用的方法
System.out.println(o);//在打印一个东西时,其实是默认调用了ToString方法,即 o.ToString
System.out.println(o.toString());//返回类型是String类型,字符串类型
// 获取该对象的哈希码值
int code =o.hashCode();
System.out.println(code);//根据o的地址值返回一个哈希码值,不同对象的哈希码值也是不一样的
// Java万物皆对象的思想
Class cl=o.getClass();
}
}
//toString方法重写经常用于构造方法是有参的,输出对象引用的时候,只要改写了toString,就可以直接输出有参构造方法的值了
//"=="运算符用于比较两个地址值是否相同
//equals 方法在父类Object类中也是比较两个地址值是否相同,但是通过改写eauals和HashCode方法,可以比较两个的字面值是否相同了
2.Scanner类
import java.util.Scanner;
public class ScannerUntils {
private ScannerUntils() {
}
public static int use(Scanner sc){
while (true){
sc=new Scanner(System.in);
boolean b=sc.hasNextInt();//为什么这里只判断一次,而不是跟nextInt()一样没循环一次都让重新输入一个
// hasNextInt()有点像缓存的机制,当调用它的时候,它的空间会存入一个值,再次调用不会覆盖或者增加,而是保持原来的值。。
if (b){
int num=sc.nextInt();
// System.out.println(num);
return num;
// break;
}else {
System.out.println("输的不对重新输");
}
}
}
}
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 常用基本类型字符串录入方法
int a=scanner.nextInt();
double b=scanner.nextDouble();
float c=scanner.nextFloat();//等等,根据自己情况来用,好多了就在这不一一打了
boolean d=scanner.nextBoolean();//这个只能输入true或者false
// String类型字符串录入方法
String e=scanner.nextLine();//这是第一种方式,这种方式会录入回车键,推荐经常使用,如果又碰到小尴尬的情况的话(比如敲完
//回车键然后被录入了,实际上不想录那个回车键,那样的话就在重新new一个Scanner对象就可以了 )
String f=scanner.next();//这是第二种方式,这种方式不会录入回车键,但是如果你打印了一些字之后要空几格,或者有换行的,
// 他就只会录入你的有换行或者空格之前的内容,后面就不录了。
}
}
public class Test1 {
public static void main(String[] args) {
// 如果用户录入的类型不是我们想要的类型,按照之前写的就会报错,导致程序的兼容性比较差,所以要提高兼容性,就用下面的方法
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个数");
boolean b = scanner.hasNextInt();//判断对象输入的是不是整数类型,进行预判
if(b){
int num =scanner.nextInt();
System.out.println(num);
}else
{
System.out.println("输入的不是整数,请重新输入");
}
while (true){
System.out.println("请再输入一个数");
int a=scanner.nextInt();
if (a==20){
System.out.println("输入对了");
break;
}else
{
System.out.println("重新输");
}
}
}
// System.out.println("dasddads");
}
用完Scanner功能后,记得调用close方法释放资源
ublic class Test2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个数");
System.out.println(ScannerUntils.use(scanner));
scanner.close();
//Scanner功能用完之后,可以用close方法关闭Scanner功能,释放资源(后面IO流常用)
}
}
3.String 类
String类介绍
ublic class Test {
public static void main(String[] args) {
}
String s = new String("dsadadsa");//这个是有参的String类,里面可以写字符串,常用
String b=new String();//这个是无参的 String构造方法,里面是空串,这个不咋常用
}
//字符串是多个字符组成的序列
//字符串可以看作是字符数组
//字符串的每个字符,从左往右都可以看成是有索引的,从0开始
//==========================
//1.String 类代表字符串。Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现。
//2.字符串是常量;它们的值在创建之后不能更改。
//如果输出的是地址值,那么这个类就没有重写toString方法
//如果输出的不是地址值,那么这个类就是重写了toString方法
//""只有两个引号,这个叫空串,打印出来什么都没有
public class Test2 {
public static void main(String[] args) {
byte [] aa=new byte[]{};
byte[] aaa=new byte[4];
int[] [] b=new int[6][3];
int [][] c=new int[][]{{},{},{},{}};
int [] []m={{},{},{}};
// 定义字节数组
byte[] a={97,97,98,99,98,99,100};//这样输的话,它会自动那这个对应ASK码表去,将其数字对应转换成字符串(记住就行)
// 将字节数组转换成字符串(记住,他的功能就是转换出来)
//String(byte[] bytes)
//通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。通俗点就是把形参的字节数组转换成字符串
String cc=new String(a);
System.out.println(cc);
System.out.println("============");
// 把字节数组的一部分转换成字符串,第二个参数表示从第几个元素开始,第三个参数表示把从第几个元素开始的长度为几的元素都转成
// 字符串
String s = new String(a, 0, 3);//将a数组从第0个字节开始(包括第0个),将三个元素转成字符串
System.out.println(s);//只显示转换字符串的部分,别的不显示
}
}
public class Test3 {
public static void main(String[] args) {
// 把字符数组转成字符串
char[] a={'a','b','c','d','的','都'};
// 可以通过构造方法将字符数组转换成字符串
// String(char[] value)
// 分配一个新的 String,使其表示字符数组参数中当前包含的字符序列。
String s = new String(a);
System.out.println(s);//这是将全部的字符数组转换成字符串
s=new String(a,2,2);//这是将字符数组的部分字符转换成字符串,从字符数组的第2个元素开始(包括第2个),将
// 后面2个元素转换为字符串
System.out.println(s);
}
}
public class Test4 {
public static void main(String[] args) {
String s = new String("fsdfsdfsdfdsfdsfdsfsd");
// 获取字符串的长度
int length=s.length();
System.out.println(length);
// Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现。
// 什么意思?就是说每个字符串不需要new,直接写出来就是一个对象,例如:
int length1 = "sadasdasdasdas".length();//直接写出来就是一个对象,当然对象类型都为String类型
// 最常用的写法都是:
String a= "dadadsadds";//不用new,直接就是对象
int length2 = a.length();
System.out.println(length2);
}
}
public class Test5 {
public static void main(String[] args) {
// 字符串是常量;它们的值在创建之后不能更改。
// 在JDK1.8之后,堆内存中有个字符串常量池
// 字符串是常量;它们的值在创建之后不能更改,指的的是,字符串的值不能被改变,你改变的无非是这个指向,指向是可以被改变的
// 就像new对象一样,s=new b(); 后s还可以=new c();指向是可以便得
// 每个字符串都是一个对象,是对象就会有地址,每写出一个字符串常量来,这个地址都会放到堆内存得常量池中
// 注意一下:两个字符串之间用"+"相连接得时候,直接合并成一个完整得字符串,并且给个地址当道字符串常量池中
}
}
public class Test6 {
public static void main(String[] args) {
// 以下这两种情况是由区别得
String s1="hello";//这句话创建了一个对象
String hello1 = new String("hello");//这句话创建了两个对象 在4-26内存图中有
// 对第二种情况,第一个,hello这个字符串直接构建了一个对象,有了一个地址x1,然后,new 对象这句话又构建了一个对象
// 它里面存着刚才得字符串地址x1,然后new对象这个地址为x2,给了引用变量hello1
String s2="helloJAVA";
String s3 = new String("helloJAVA");
System.out.println(s2==s3);
System.out.println(s2.equals(s3));//String类重写了equals方法,直接比较其字面值是否相等,不论你什么形式,它值比较字面值
// 所以是true
boolean j="abc".equals("abC");
System.out.println(j);//equals区分大小写
boolean h="abc".equalsIgnoreCase("ABC");//这个方法不区分大小写(忽略大小写)
System.out.println(h);
}
}
//String 类重写了toString方法,输出的不在是该引用的地址值,而是打印字符串的字面内容
//String 类重写了equals方法,不在比较两个字符串的地址值是否相同,而是比较两个字符串字面上的内容是否相等,区分大小写
String功能介绍
//String类的判断功能
public class Test {
public static void main(String[] args) {
// String方法:
// 这个方法用于判断两字符串字面值是否相等(忽略大小写)
boolean a="ABC".equalsIgnoreCase("abc");
System.out.println(a);
// String方法:
// 判断字符串是否为空串
boolean b="ddasd".isEmpty();
System.out.println(b);
// 判断字符串是否以某个字符串开头
boolean h = "王语嫣".startsWith("王");
boolean h1 = "王语嫣".startsWith("王语");//看的是这个字符串的第一个字
System.out.println(h);
//判断某个字符串是不是以某个字符串结尾,注意,无论开头还是结尾,这个字符串除了空串之外不能是单独的一个字
boolean h2 = "段誉".endsWith("誉");
boolean h4 = "欲语泪先流".endsWith("泪先流");//看的是这个字符串的最后一个字
System.out.println(h4);
// 判断一个字符串是否包含一个字串:
boolean h3 = "我想带你去浪漫土耳其".contains("土耳其");
System.out.println(h3);
}
}
package String类常用功能;
//String的获取功能
public class Test1 {
public static void main(String[] args) {
// 根据索引获取单个字符:
char h="1234我爱你".charAt(2);//单个字符用char类型,charAt()中填的是字符串的索引值或者叫下标值
System.out.println(h);
String m="sdasdadadds";
char h1=m.charAt(m.length()-1);//获取最后一个
// 查找该字符或者该字符串第一次出现的索引
String k="我爱你我爱你我爱你";
// indexof从头开始找,并且从左往右
int index=k.indexOf("爱");//里面可以放单个字符,也可以放一段字符串,也是从这一小段的字符串的第一个字找
System.out.println(index);
// 从指定索引往后查找
int index1=k.indexOf("爱",2);//从索引值为2的地方开始找,后面所出现的'爱'这个字符
System.out.println(index1);
int index2=m.indexOf("da",m.indexOf("da")+1);//可以写一个字符,也可以写一个字符串,这个听常用的,字符串的
// 的话也是找字符串的第一个字符
System.out.println(index2);
// 如果没有找到,就会返回-1,-1经常是表示找不到。
// =======================================================
// 从后往前找第一次出现的字符或字符串的索引
String f="fasdfasffbgsdgbsgadgadgadgdagdagda";
int index6=f.lastIndexOf("g");
System.out.println(index6);
int index4=f.lastIndexOf("d",10);//表示从索引值为10 的地方从后往前找,找"d"这个字符首次出现的位置
System.out.println(index4);
// 截取字符串
String l="我在人民广场吃着炸鸡,而此时此刻你在哪里";
String k1=l.substring(2);//从指定索引处开始截取,截取到末尾返回,会把索引值截取进去
System.out.println(k1);
// 如果想截取一段,可以定义两个索引
String substring = l.substring(0, 5);//含头不含尾,包含头部索引的字符,但是不包含尾部包含的字符
}
}
package String类常用功能;
//遍历字符串
public class Test2 {
public static void main(String[] args) {
String a="我在任命广场吃着炸鸡大书法家反馈发放了咖啡尼可拉省的方式的";
// char h;
for (int i = 0; i < a.length(); i++) {
char h=a.charAt(i); //为啥这里可以直接写 char h,因为个循环每赋值一次就把h丢掉了,再进来是对h进行重新的定义与赋值
// 上述是自己总结的
System.out.println(h);
}
for (int i = a.length()-1; i >= 0; i--) {
char h=a.charAt(i);
System.out.println(h);
}
}
}
//如果要求统计问题的时候,一定要写上统计变量
public class Test4 {
public static void main(String[] args) {
// 统计下列字符串中,小写字符,大写字符以及数字字符的个数:
//如果要求统计问题的时候,一定要写上统计变量
int da=0;
int xiao=0;
int shu=0;
String a="fdffdfaffhfkgljdlfgj4579023fh32FASFSAF43hfSDFHJKKDSHFSDJV983g30jfk29FASFSA4f3209fh230";
for (int i = 0; i < a.length(); i++) {
char h=a.charAt(i);
if(h>='a'&&h<='z'){
xiao++; }else if (h>='A'&&h<='Z'){
da++;
}else if (h>='1'&&h<='9'){
shu++;
}
}
System.out.println("大写字母为"+da+"个");
System.out.println("小写字母为"+xiao+"个");
System.out.println("数字为"+shu+"个");
}
}
package String类常用功能;
//String类中与转换功能有关的方法
public class Test5 {
public static void main(String[] args) {
//把一个字符串,转换为字节数组
String h="ddadasdd";
byte[] bytes=h.getBytes();//这个方法,将字符串转换为字节数组
for (int i = 0; i < bytes.length; i++) {
int a=bytes[i];
System.out.println(a);
}
System.out.println(bytes.length);
// 把字节数组转换成字符串
String m=new String(bytes);
System.out.println(m);
String s="我爱你";//对于UTF-8编码制度:一个汉字对应三个字节,一个字节存一个数字,所以一个汉字对应着三个数字
byte[] kk=s.getBytes();
for (int i = 0; i < kk.length; i++) {
int a=kk[i];
System.out.println(a);
}
System.out.println(kk.length);
String s1 = new String(kk, 0, 6);//一个汉字对应三个字节,也就是在byte数组里对应着三个汉字,所以需要6个长度的数组
System.out.println(s1);
}
}
package String类常用功能;
//将字符串转换为字符数组
public class Test6 {
public static void main(String[] args) {
String l="草泥马深度负反馈拉法兰发了疯";
char[] chars=l.toCharArray();//将字符串转换为字节数组
// System.out.println(chars.length);
for (int i = 0; i < chars.length; i++) {
char k=chars[i];
System.out.println(k);
}
// 把一个字符数组转换成字符串
String m=new String(chars);
System.out.println(m);
}
}
package String类常用功能;
//value of方法,这是静态方法
public class Test7 {
public static void main(String[] args) {
// valueOf()静态方法,可以把很多类型转换成字符串
// 把一个整数转换成字符串
int num =100;
System.out.println(num+"");//这样就把100变成了字符串类行
String a=String.valueOf(100);//这样直接一键将整数型100转成了字符串型
String b=String.valueOf('d');//这样直接一键将zifu型d转成了字符串型
String c=String.valueOf(1010L);//……
System.out.println(a);
System.out.println(b);
System.out.println(c);
String d=String.valueOf(new char[]{'a','b','c','d'});//valueof方法这是
String e=new String(new char[]{'a','b','c','d'});//用构造方法转
String s1="dasdasFFSSd".toUpperCase();//将小写字母转为大写字母
System.out.println(s1);
String s2="FSDFFFASFSfasf".toLowerCase();//将da写字母转为xiao写字母
System.out.println(s2);
// 拼接字符串 除了加号拼的另一种方法
String s3="dass".concat("dsada").concat("dasdasda").concat("dasdsa");//链式变成
System.out.println(s3);
}
}
package String类常用功能;
//替换功能
public class test8 {
public static void main(String[] args) {
String str="奥巴马和特朗普";
String str1=str.replace('奥','*');//将奥字替换为*
System.out.println(str1);
String s = str.replace("奥巴马", "***");//可直接替换字符,也可以替换字符串
System.out.println(s);
// 链式编程:
String s1 = str.replace("奥巴马", "**").replace("特朗普", "****");
System.out.println(s1);
}
}
package String类常用功能;
//trim功能:去除字符串两端空格
public class Test9 {
public static void main(String[] args) {
String a= " 1234 ";
String trim = a.trim();
System.out.println("======"+trim+"======");
}
}
package String类常用功能;
//字符串的比较(除equals的另一种方法)
//现在的编码格式是默认的UTF-8,英文与ASKII表是一致对应的,中文的暂时不清楚
public class Test10 {
public static void main(String[] args) {
boolean a="abc".equals("ddd");//这是布尔类型的比较
// 比较字符串,返回值是int类型
// 两字符串长度相同时
int i="abc".compareTo("bBC");//其原理是直接用其对应的ASKII码表的值相减,相同时就返回0,先从第一个值开始相减,如果第一个为0
// 那么就开始减第二个值,以此类推,一直到不相同的那个数或者都减完都是0位置,只要有一个不为0的值得时候,返回这个值,结束.
System.out.println(i);
int ii ="abcd".compareTo("SB");//如果长度不一样是时,就直接按长度去减了
System.out.println(ii);
// 这个比较方法有时是必须需要返回类型是整数型时用到的
}
}