string:字符串内容是不会发生变化的,它的对象在创建后不能被更改。
创建字符串对象:
1:直接赋值:string str=“hghg”;
2:
构造方法 | 说明 |
---|---|
public string() | 创建空白字符串,不含任何内容 |
public string(string original) | 根据传入字符串,创建字符串对象 |
public string(char[] chs) | 根据字符数组创建字符串对象 |
public string(byte[] chs) | 根据字节数组,创建字符串对象 |
package com.cn.co;
import java.sql.SQLOutput;
public class Test {
public static void main(String[] args) {
// 1:
String s1="abs";
// 2:
String s2=new String();//空字符串
// 3:
String s3=new String("jhjhj");
// 4:
char[] ch={'a','b','c'};
String s4=new String(ch);//abc
// 5:
byte[]by={97,98,99};
//通过阿斯克码转换
String s5=new String(by);//abs
}
}
string s1=“abc”;
string s2=“abs”;
当我们使用双引号直接赋值,系统就会检查字符串是否在串池出现,不存在就创建新的
引用类型:
方法 | 属性 |
---|---|
boolean equals方法(要比较字符串) | 完全一样结果才是true |
boolean equalslgnoreCase(要比较字符串)) | 忽略大小写 |
案例1:用户登录
package com.cn.co;
import java.sql.SQLOutput;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
String str1="zhangsan";
String str2="123456";
// 模拟用户输入
Scanner sc=new Scanner(System.in);
System.out.println("请输入用户名");
String username=sc.next();
System.out.println("请输入密码");
String password=sc.next();
// 判断是否正确
if(username.equals(str1)&&password.equals(str2))
{
System.out.println("用户成功");
}
else{
System.out.println("失败");
}
}
}
遍历字符串
package com.cn.co;
import java.sql.SQLOutput;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
String str="kugdakugvd";
String str1=new String("wjhdbjhedb");
for(int i=0;i<str.length();i++)
{
// i表示字符串的每一个索引
char s=str.charAt(i);
System.out.print(s);
}
}
}
拼接字符串:
package com.cn.co;
import java.sql.SQLOutput;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int arr[]={1,2,3};
String s=arrtostring(arr);
System.out.println(s);
}
public static String arrtostring(int []arr)//接收一个数组
{
if(arr==null)
{
return "";
}
if(arr.length==0)
{
return "[]";
}
String result="";
for (int i=0;i< arr.length;i++)
{
result= result+arr[i];
}
return result;
}
}
方法:string substring(int beginindex,int endIndex)截取字符串
包头不包尾,包尾不包头
string substring(int beginIndex)截取到末尾
案例:手机号屏蔽:
public class Test {
public static void main(String[] args) {
String phone="2873681746";
String s=phone.substring(0,3);
String str=phone.substring(7);
System.out.println(s+"******"+str);
}
}
StringBuilder:
可以看成一个容器,创建以后里面内容是可变的:提高字符串的操作效率
,创建以后里面的内容是可以变化的。
StringBuilder的构造方法
方法名 | 说明 |
---|---|
public StringBuilder() | 创建一个空白可变字符串对象,不含有任何内容 |
public StringBuilder(String str) | 根据字符串内容,来创建可变字符串对象 |
成员方法;
方法名 | 说明 |
---|---|
public StringBuild append(任意类型) | 添加数据,并返回对象本身 |
public StringBuilder reverse() | 反转容器里面的内容 |
public int length() | 返回长度 |
public String toString() | 通过toString’()就可以实现把StringBuild转换为String |
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abc");
// 添加元素
sb.append(1);
sb.append(2.3);
sb.append(true);
// 反转字符串
sb.reverse();
// 获取长度
int len=sb.length();
System.out.println(len);
System.out.println(sb);
}
}
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abc");
// 添加字符串
sb.append("aaa");
sb.append("nnn");
// 把StringBuffer变回字符串
String str= sb.toString();
System.out.println(str);
}
}
链式编程
public class Test {
public static void main(String[] args) {
// 链式编程 当我们在调用一个方法的时候 不需要用变量接受它的值,可以继续调用其他方法
StringBuffer sb=new StringBuffer();
sb.append("aaa").append("bbb").append("ccc");//链式编程
System.out.println(sb);
String str=sb.toString();
System.out.println(str);
}
}
利用StringBuffer()做题:例子判断字符串是否为对称字符串
public class Test {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str= sc.next();
// 把字符串转换为StringBuffer()类型
// StringBuffer sb=new StringBuffer();
// sb.append(str);
// sb.reverse();
//String st=sb.toString();
// if(st.equals(str))
// {
// System.out.println("yes");
// }
String sb=new StringBuffer().append(str).reverse().toString();
if(sb.equals(str))
{
System.out.println("yes");
}
}
}
StringJoiner:
StringJoiner和StringBuilder一样可以看成一个容器,创建以后里面内容可以换。
作用:提高字符串的操作效率,而且代码编写讲解。
构造方法:
方法名 | 说明 |
---|---|
public StringJoiner(间隔符号) | 创建一个StringJoiner对象,指定拼接的间隔符号 |
public StringJoiner(间隔符号,开始符号,结束符号) | 创建一个StringJoiner对象,指定拼接时的间隔符号,开始符号,结束符号 |
成员方法:
方法名 | 说明 |
---|---|
public StringJoiner add(添加的内容) | 添加数据,并返回对象本身 |
public int length() | 返回长度 |
public String toString() | 返回一个字符串 |
public class Test {
public static void main(String[] args) {
StringJoiner sj=new StringJoiner("---");
// 添加元素
sj.add("aaa").add("bbn").add("jjj");
// 打印结果
System.out.println(sj);//输出结果aaa---bbn---jjj
}
}
字符串原理:
1:字符串储存的内存原理;
直接赋值会复用字符串池中的。
new出来的不会复用,而是开辟一个新的空间
2:==号比较的是什么
基本数据类型比较的是数据值
引用数据类型比较的是地址值
集合:长度可变的容器,自动扩容。不能直接存基本数据类型。
数组长度固定,集合长度可变,数组可以存基本数据类型引用数据类型,集合只能存引用数据类型,如果要存基本数据类型要把其包装类。
基本数据类型的包装类:
byte ->Byte
short->Short
char->Character
int->Integer
long->Long
float->Float
double->Double
boolean->Boolean
public class Test {
public static void main(String[] args) {
// 1:创建集合对象
// 2:泛型:限定集合中存储数据的类型
// 此时我们创建的是ArryList的对象,而ArrarList是java已经写好的一个类
// 这个类在底层做了一些处理
// 打印对象不是地址值,而是集合中存储数据内容
// 在展示时会把[]把所有的数据进行包裹
ArrayList<String> list=new ArrayList<String>();
System.out.println(list);
}
方法名 | 说明 |
---|---|
boolean add(E e) | 添加元素,返回值表示是否添加成功 |
boolean remove(E e) | 删除指定元素,返回值表示是否删除成功 |
E remove(int index) | 删除指定索引的元素,返回被删除的元素 |
E set(int index,E e) | 修改指定索引的元素,返回原来的元素 |
E get(int index) | 获取指定索引的元素 |
int size() | 集合的长度 |
public class Test {
public static void main(String[] args) {
// 1:创建集合对象
// 2:泛型:限定集合中存储数据的类型
// 此时我们创建的是ArryList的对象,而ArrarList是java已经写好的一个类
// 这个类在底层做了一些处理
// 打印对象不是地址值,而是集合中存储数据内容
// 在展示时会把[]把所有的数据进行包裹
ArrayList<String> list=new ArrayList<String>();
// 1: 添加元素
list.add("jsdnhdsbjedb");
list.add("kkkkk");
list.add("aaa");
// 删除元素,返回是否删除成功
boolean f=list.remove("aaa");//true
System.out.println(f);
// 删除指定索引的元素,返回被删除的元素
// String str1=list.remove(1);//aaa
// System.out.println(str1);
// 修改指定索引元素,返回指定索引上原来元素
String result=list.set(0,"ddd");
System.out.println(result);//jsdnhdsbjedb
System.out.println(list);//[ddd,kkkkk,aaa]
// 查询指定索引上元素
String s=list.get(0);
System.out.println(s);//ddd
// 遍历
for(int i=0;i< list.size();i++)
{
String p=list.get(i);
System.out.println(p);
}
}
案例:
public static void main(String[] args) {
// 需求:定义一个集合,添加数字,并进行遍历,遍历格式参照:[元素1,元素2,元素3]
// 1:创建集合
ArrayList<Integer> list=new ArrayList<>();
// 2:添加元素
list.add(1);
list.add(2);
list.add(3);
list.add(4);
// 3:遍历
System.out.println(list);
}
}
public static void main(String[] args) {
// 需求:定义一个集合,添加字符,并进行遍历,遍历格式参照:[元素1,元素2,元素3]
// 1:创建集合
ArrayList<Character> list=new ArrayList<>();
// 2:添加元素
list.add('a');
list.add('b');
list.add('c');
list.add('d');
// 3:遍历
System.out.println(list);
}
}
案例
1:test和stu在一个包里
public class Test {
public static void main(String[] args) {
// 需求:定义一个集合,添加学生对象,并进行遍历学生类属性为:姓名,年龄
// 1:创建集合
ArrayList<stu> list=new ArrayList<>();
// 创建学生对象
stu s1=new stu("zhansan",18);
stu s2=new stu("lisan",19);
stu s3=new stu("tq",18);
// 2:添加元素
list.add(s1);
list.add(s2);
list.add(s3);
// 3:遍历
for(int i=0;i<list.size();i++)
{
stu s=list.get(i);
System.out.println(s.getName()+","+s.getAge());
}
}
1.1
public class Test {
public static void main(String[] args) {
// 需求:定义一个集合,添加学生对象,并进行遍历学生类属性为:姓名,年龄
// 1:创建集合
ArrayList<stu> list=new ArrayList<>();
// 创建学生对象,加入集合
Scanner sc=new Scanner(System.in);
for(int i=0;i<3;i++)
{
stu s=new stu();
System.out.println("请输入学生名字");
String name=sc.next();
System.out.println("请输入年龄");
int age=sc.nextInt();
// 把name和age赋值给学生对象
s.setName(name);
s.setAge(age);
// 加入集合
list.add(s);
}
// 3:遍历
for(int i=0;i<list.size();i++)
{
stu s=list.get(i);
System.out.println(s.getName()+","+s.getAge());
}
}
}
2:
public class stu {
// 1:私有化成员变量
// 空参构造方法
// 带全部参数的构造函数
// get、set方法
private String name;
private int age;
public stu(String name, int age) {
this.name = name;
this.age = age;
}
public stu() {
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
案例:Main和phone在一个包
//筛选价格小于3000的手机信息
public class Main {
public static void main(String[] args) {
ArrayList<phone>list=new ArrayList<>();
//ArrayList<phone>li=new ArrayList<>();
phone u1=new phone("小米",1000);
phone u2=new phone("华为",8000);
phone u3=new phone("苹果",9000);
// 添加到集合
list.add(u1);
list.add(u2);
list.add(u3);
chazhao(list);
}
public static void chazhao(ArrayList<phone>list)
{
for (int i=0;i< list.size();i++)
{
phone p=list.get(i);
int price=p.getJg();
if(price<3000)
{
//li.add(p);
System.out.println(p.getJg()+","+p.getPp());
}
}
//return li;
}
}
public class phone {
private String pp;
private int jg;
phone(){
}
phone(String pp,int jg)
{
this.pp=pp;
this.jg=jg;
}
public String getPp() {
return pp;
}
public void setPp(String pp) {
this.pp = pp;
}
public int getJg() {
return jg;
}
public void setJg(int jg) {
this.jg = jg;
}
}
案例:学生管理系统:
Math:里面
方法都是静态的
方法名 | 说明 |
---|---|
public static int abs(int a) | 获取参数绝对值 |
public static double ceil(double a) | 向上取整 |
public static double floor(double a) | 向下取整 |
public static int round(float a) | 四舍五入 |
public static int max(int a,int b) | 获取最大值 |
public static double pow(double a,double b) | 返回a的b次幂 |
public static double random | 返回值为double的随机值,范围[0.0,1.0) |
public static double sqrt(double a) | 返回a的平方根 |
public static double cbrt(double a) | 返回a的立方根 |
package com.cn.co;
import java.sql.SQLOutput;
public class Test {
public static void main(String[] args) {
// abs获取参数绝对值
int a=Math.abs(-66);
System.out.println("abs的输出:"+a);
// ceil向上取整(正负值都可,向上往大取)
double b= Math.ceil(3.4);
System.out.println("ceil的输出:"+b);
// floor向下取整(正负值都可,向下往小取)
double c=Math.floor(3.4);
System.out.println("floor的输出:"+c);
// round四舍五入
double d=Math.round(4.4);
System.out.println("round的输出:"+d);
// max获取两个整数最大值
double max=Math.max(3.1,5.6);
System.out.println("max的输出:"+max);
// pow获取a的b次幂
double u=Math.pow(3,2);
System.out.println("pow的输出:"+u);
// random返回随机值
System.out.println(Math.random());
}
}
abs的输出:66
ceil的输出:4.0
floor的输出:3.0
round的输出:4.0
max的输出:5.6
pow的输出:9.0
0.38015358435326185
System:
方法名 | 说明 |
---|---|
public static void exit(int status) | 终止当前运行的java虚拟机 |
public static long currentTiMillis() | 返回当前系统的时间毫秒值形式 |
public static void arraycopy(数据源数组,起始索引,目的地数组,起始索引,拷贝个数) | 数组拷贝 |
package com.cn.co;
import java.sql.SQLOutput;
public class Test {
public static void main(String[] args) {
// 方法的形参:
// 1: 状态码:
// 0:表示当前虚拟机是正常停止
// 非0:表示当前虚拟机是异常停止
//System.exit(0);
// 下面代码都不会执行了
//System.out.println("看看我停止了吗");
//2:返回从时间原点开始到现在时间毫秒数
long l=System.currentTimeMillis();
System.out.println(l);
// 3:arraycopy数组拷贝,如果两个都是基本数据类型两个数组类型应该一样,
// 两个都是引用数据类型,则可以子类型赋给父类型
int a[]={1,2,3,4,5,6,7,8,9,10};
int[]arr2=new int[10];
// 把arr1里面数据拷贝到arr2
// 参数1:要拷贝的数据从哪个数组里面来,
// 参数2:从数据源数组第几个索引开始拷贝,
// 参数3:目的地,要把参数拷到哪个数组
// 参数4:目的地数组的索引
// 参数5:拷贝数据数
System.arraycopy(arr1,0,arr2,0,10);
}
}
runtime:当前虚拟机运行环境
里面方法不是静态的。
package com.we.wd;
public class runtime {
public static void main(String[] args) {
//public static RunTime 当前系统的运行环境对象
//public void exit(int status) 停止虚拟机
//public int availbleProcessors 获取cpu的线程数
// 1:获取runtime对象
Runtime ri=Runtime.getRuntime();
Runtime r2=Runtime.getRuntime();
// 2:停止虚拟机
//ri.exit(1);
System.out.println("看看我执行了吗");
// 3:获取cpu的线程数
System.out.println(ri.availableProcessors());
// 4:总内存大小
System.out.println(ri.maxMemory());
// 5:已经获取的内存大小
System.out.println(ri.totalMemory());
// 6:剩余空间大小
System.out.println(ri.freeMemory());
// 7:运行cmd命令
System.out.println(ri.exec("notepad" ));
}
}
object:object是java中的顶级父类,所有的类都直接或者间接的继承于object类。
object类中方法可以被所有子类访问,所以我们要学习object类和里面方法。
object里面只有无参构造函数
package com.ww.wen;
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// toString方法的重写
@Override
public String toString() {
return name+","+age;
}
@Override
//这里重写方法比较的是对象内部的属性值
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
}
package com.ww.wen;
public class objecto {
public static void main(String[] args) {
Object obj=new Object();
String str=obj.toString();
System.out.println(str);//java.lang.Object@1b6d3586
// 细节
//System:类名
//out;静态变量
//System.out:获取打印的对象
//println:方法
//参数:要打印的内容
//当我们打印一个对象的时候,底层就会调用对象的toString方法,把对象变成字符串,然后
//打印早控制台
//默认情况下,因为Object类中toString方法返回的是地址值。所以默认情况我们打印一个对象打印的是地址值
//我们要看对象内部属性值应该怎么办:重写父类中的方法
Student stu=new Student("lisi",19);
String str2=stu.toString();
System.out.println(str2);//lisi,19
// toString结论
// 如果我们要打印应该对象,想要看到它的属性值的话,那么就重写toString方法
// 再重写方法中把对象属性值进行拼接
}
}
package com.ww.wen;
public class objecto {
public static void main(String[] args) {
Object obj=new Object();
String str=obj.toString();
System.out.println(str);//java.lang.Object@1b6d3586
// 细节
//System:类名
//out;静态变量
//System.out:获取打印的对象
//println:方法
//参数:要打印的内容
//当我们打印一个对象的时候,底层就会调用对象的toString方法,把对象变成字符串,然后
//打印早控制台
//默认情况下,因为Object类中toString方法返回的是地址值。所以默认情况我们打印一个对象打印的是地址值
//我们要看对象内部属性值应该怎么办:重写父类中的方法
Student stu=new Student("lisi",19);
String str2=stu.toString();
System.out.println(str2);//lisi,19
// toString结论
// 如果我们要打印应该对象,想要看到它的属性值的话,那么就重写toString方法
// 再重写方法中把对象属性值进行拼接
}
}