常用 API(String、ArrayList)
› API(Application Programming Interface，应用程序编程接口)
● Java写好的技术(功能代码)，可以直接调用.
● Oracle 也为Java提供了这些功能代码和相关的API文档(技术使用说明书).
▼ 下载API文档网址
http://www.oracle.com/technetwork/java/javase/downloads/index.html
---------------------------------------------------------------------------------
String 简单介绍
● String类定义的变量可以用于储存字符串，同时String类提供了很多操作字符串的功能，我们可以直接使用.
＞ 关于 String 类学什么？
› String 定义变量储存字符串
◣需要知道如何创建字符串对象，并用String定义变量指向该字符串对象.
› String 的内存原理
◣字符串对象在内存中的原理是什么样.能够解决一些字符串的成绩面试题.
› String 类提供了哪些API
◣能够说出并使用String类提供的操作字符串的功能：遍历、替换、截取、相等、包含···
› String 解决实例
◣能够利用String的常用API去解决实际场景的业务需求，真正做到学以致用
◆ String 类概述
● Java.lang.String 类代表字符串，String类定义的变量可以变量可以用于指向字符串对象，然后操作该字符串.
● Java 查询中的所有字符串文字(例如：“abc”)都为此类的对象
＞ String 类的特点详解
● String起始常被称为不可改变字符串类型，它的对象在创建后不能被更改.
＞ String是不可变字符串的原因 ：
● String变量每次的修改其实都是产生并指向了类的字符串.
● 原来的字符串对象都是没改变的，所以称不可变字符串.
◆ String 类创建对象的2种方式
＞ 方式一：总结使用 " " 定义.
String Word="文字";
＞ 方式二：通过String 类的构造器创建对象
| 构造器 | 说明 |
|---|---|
| public String() | 创建一个空白字符串对象，不含如何内容 |
| public String(String original) | 根据传入的字符内容，来创建字符串对象 |
| public String(char[] chs) | 根据字符组的内容，来创建字符串对象 |
| public String(byte chs) | 根据字节数组的内容，来创建字符串对象 |
public class StringDemo1 {
public static void main(String[] args) {
//方式一: 直接使用双引号得到字符串对象
String Word="文字";
System.out.println(Word);
//方式二:
//1.public String(): 创建一个空白字符串对象,不含如何内容（几乎不用）
String s1 = new String(); //s1 = ""
System.out.println(s1);
//2.public String(String): 根据传入的字符内容，来创建字符串对象（几乎不用）
String s2 = new String("文字");
System.out.println(s2);
//3.public String(char[] c): 根据字符组的内容，来创建字符串对象
char[] chars = {'a','b','中','国'};
String s3 = new String(chars);
System.out.println(s3);
//4.public String(byte b): 根据字节数组的内容，来创建字符串对象
byte[] bytes={97,98,99,65,66,67};
String s4=new String(bytes);
System.out.println(s4);
}
}
◆ String 类创建面试题
＞ 有什么区别吗？(面试参考)
● 以 " " 方法给出的字符串对象，在字符串常量池中存储，而且相同内容只会在其中存储一份.
● 通过构造器new 对象，每new 一次都会产生一个新对象，放在堆内存中.
public class StringDemo1 {
public static void main(String[] args) {
String ss1 = "abc";
String ss2 = "abc";
System.out.println(ss1 == ss2);
char[] char1 = {'a','b','c'};
String ss3 = new String(char1);
String ss4 = new String(char1);
System.out.println(ss3 == ss4);
}
}
◆ String 类常用API - 字符串内容比较
● 使用 ‘==’ 比较的的是地址 (比对基本数据类型)
● 使用 ‘equals’ 比较的的是内容 (比对引用数据类型)
● 使用 'equalsIgnoreCase ’ 忽略大小写进行比较的的是内容 (比对引用数据类型)
| 方法名 | 说明 |
|---|---|
| public bool equals (Object anObject) | 将次字符串与指定对象进行比较.只关心内容是否一致 |
| public bool equalsIgnoreCase (String anotherString) | 将次字符串与指定对象进行比较.忽略大小写进行比较 |
import java.util.Scanner;
public class StringDemo2 {
public static void main(String[] args) {
//成员变量
String Name = "用户";
String Pwd = "123456";
//接收值
Scanner input = new Scanner(System.in);
System.out.print("请输入用户名: ");
String name = input.next();
System.out.print("请输入密码: ");
String pwd = input.next();
//与成员变量比对接收值
System.out.println("------此处使用的是 '==' 进行的比对-----");
if(name == Name && pwd == Pwd){
System.out.println("正确");
}else {
System.out.println("错误");
}
System.out.println("------此处使用的是 '.equals(比对值)' 进行的比对-----");
if(name.equals(Name) && pwd.equals(Pwd)){
System.out.println("正确");
}else {
System.out.println("错误");
}
}
}
◆ String 类常用API - 遍历、替换、截取、分隔操作
● 常用API
| 方法名 | 说明 |
|---|---|
| public int length() | 返回此字符串的长度 |
| public char charAt(int index) | 获取某个索引位置的字符 |
| public char[ ] toCharArray() | 将当前字符串转换成为字符数组返回 |
| public String substring(int beginIndex, int endIndex) | 根据开始火绒结束索引进行截取，得到新的字符串(包前不包后) |
| public String substring(int beginIndex) | 从传入的索引处截取，截取到末尾，得到新的字符串 |
| public String replace(charSequence target,charSequence replacement) | 使用新值，将字符串的旧值替换，得到新的字符串 |
| public String[ ] split(String regex) | 根据传入的规则切割字符串，得到字符串数组返回 |
public class StringAPIOtherDemo3 {
public static void main(String[] args) {
//1.public int length(): 获取字符串的长度
String word = "我爱祖国Love";
System.out.println(word.length());
//2.public char charAt(int index): 获取某个索引位置处的字符
char c=word.charAt(4);
System.out.println(c);
System.out.println("----------遍历字符串中的每个字符--------");
for (int i=0; i<word.length(); i++) {
char cr = word.charAt(i);
System.out.println(cr);
}
//3.public char[ ] toCharArray(): 把字符串换成字符数组
char[] ar=word.toCharArray();
System.out.println();
for (int i=0; i<ar.length; i++){
char ch=ar[i];
System.out.println(ch);
}
//4.public String substring(int beginIndex, int endIndex): 截取内容，包前不包后
String name = "Java是世界最厉害的语言";
String rs1 = name.substring(0,9);
System.out.println(rs1);
String rs2 = name.substring(5,10);
System.out.println(rs2);
//5.public String substring(int beginIndex): 从当前索引一直截取到末尾
String rs3 = name.substring(4);
System.out.println(rs3);
//6.public String replace(charSequence target,charSequence replacement): 比对文字，并替换
String name2 = "张三厉害，张三狂徒.";
String rs4 = name2.replace("张三","**");
System.out.println(rs4);
//7.public Boolean contains(CharSequence s): 比对当前成员变量中是否存在该变量
System.out.println(name2.contains("张三"));
System.out.println(name2.contains("张三"));
//8.public Boolean startsWithstand(String prefix): 比对是否为当前成员变量的开头
System.out.println(name.startsWith("张三"));
System.out.println(name.startsWith("张三厉害"));
System.out.println(name.startsWith("张三棒棒"));
//9.public String[ ] split(String s):搜索某个内容把字符串分割成字符串数组返回
String name3 = "张三,李四,王五";
String[] names = name3.split(",");
for (int i=0; i<names.length; i++){
System.out.println("选择了:"+names[i]);
}
}
}
◆ String 类实例
● 实现随机生成验证码
import java.util.Random;
/* 使用String完成随机5位数的验证码 */
public class StringCode {
public static void main(String[] args) {
//1.定义可取的字符范围
String verification = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
//2.利用 For 循环5次,每次循环从 verification 变量中随机取走一个字符
Random random=new Random();
String Code="";
for (int i=0; i<5; i++){
//按verification变量的长度随机生成一个数
int index = random.nextInt(verification.length());
//利用public char charAt(int index): 获取某个索引(index)位置处的字符
char c = verification.charAt(index);
//将获取到的随机值连起来通过Code接收
Code += c;
}
System.out.println(Code);
}
}
● 模拟用户登录
import java.util.Scanner;
/*
模拟用户登录,3次重新登录机会
*/
public class StringLogin {
public static void main(String[] args) {
//成员变量
String Name = "用户";
String Pwd = "123456";
//接收用户输入信息
Scanner input = new Scanner(System.in);
for (int i=0; i<3;i++){
System.out.print("请输入用户名: ");
String name=input.next();
System.out.print("请输入密码: ");
String pwd=input.next();
if (name.equals(Name)){
if (pwd.equals(Pwd)){
System.out.println("登录成功");
break;
}else {
System.out.println("密码输入错误，请重新输入.你还有"+(2-i)+"机会");
}
}else {
System.out.println("用户名错误，请重新输入，你还有"+(2-i)+"机会");
}
}
}
}
● 手机号码屏蔽
import java.util.Scanner;
/* 接收号码，并替换号码 */
public class StringPhone {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入你的电话号码: ");
String Phone=input.next();
String s=Phone.substring(3,9);
String Replace=Phone.replace(s,"******");
System.out.println("你的电话为: "+Replace);
}
}
---------------------------------------------------------------------------------
ArrayList 简单介绍
● ArrayList 代表的是集合类，集合是一种容器，不同的是集合的大小是不固定的.
● 通过ArrayList 的对象代表得到一个集合容器，同时ArrayList 提供了比数组更好用，更丰富的API(功能)给程序员使用.
＞ 关于 ArrayList 类学什么？
› ArrayList 集合如何创建对象
◣要知道如何利用ArrayList 创建对象代表集合容器来存放数据.
› ArrayList 常用API
◣能够说出并使用ArrayList 类提供的丰富的元素操作的功能：添加、获取、删除、修改等功能.
› ArrayList 存储自定义对象
◣能够使用ArrayList存储自定义的对象，并清楚ArrayList 集合存储对象的底层原理.
› ArrayList 解决实例
◣能够使用ArrayList 存储对象，并完成数据搜索，删除···创建业务需求.
◆ ArrayList 集合概述
● 数组的特点
数组定义完成并启动后，类型确定、长度固定.
数组适合用于数据个数和类型确定的场景
● 集合的特点
集合类型可以不固定，大小是可变
集合适合数据个数不确定，且要做增删改查元素的场景
◆ ArrayList 集合快速入门
● ArrayList集合
ArrayList是集合中的一种，它支持索引.
● ArrayList集合的对象获取
| 构造器 | 说明 |
|---|---|
| public ArrayList() | 创建一个空的集合对象 |
● ArrayList集合添加元素的方法
| 方法名 | 说明 |
|---|---|
| public Boolean add(E e) | 将指定的元素加到此集合的末尾 |
| public void add(int index,E element) | 在此集合的指定位置插入指定的元素 |
------代码展示-------
import java.util.ArrayList;
public class ArrayListDemo1 {
public static void main(String[] args) {
//1.创建ArrayList集合对象
ArrayList list = new ArrayList();
//2.添加数据
list.add(120);
list.add(9.8);
list.add("Java");
list.add('中');
list.add("集合中可以添加各种类型的数据");
System.out.println(list);
//3.向指定位置添加数据
list.add(1,"hollow");
System.out.println(list);
}
}
◆ ArrayList 对泛型的支持
● 泛型概述
ArrayList: 起始就是一个泛型类，可以在编译阶段约束集合只能操作某种数据类型.
● 案例
ArrayList: 此集合只能操作整数类型的元素
ArrayList: 此集合只能操作字符串类型的元素
※注意: 集合中只能存储引用类型，不支持基本数据类型
------代码展示-------
import java.util.ArrayList;
/* 目标: 能够使用ArrayList集合操作的数据类型 */
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList<Object> listObject=new ArrayList<>(); //支持所有的类型
listObject.add(120);
listObject.add(9.8);
listObject.add("Java");
listObject.add('中');
listObject.add("集合中可以添加各种类型的数据");
ArrayList<String> listString1=new ArrayList<String>(); //只支持String类型
ArrayList<String> listString2=new ArrayList<>(); //从JDK 1.7开始,泛型后面的类型声明可以不写
//listString2.add(120);
//listString2.add(9.8);
listString2.add("Java");
listString2.add("集合中只支持String类型的数据");
ArrayList<Integer> listInteger=new ArrayList<>(); //只支持String类型
listInteger.add(120);
//listInteger.add(9.8);
//listInteger.add("Java");
}
}
◆ ArrayList 常用API - 遍历
● ArrayList集合常用方法
| 方法名称 | 说明 |
|---|---|
| public E get(int index) | 返回指定索引处的元素 |
| public int size() | 返回集合中的元素的个数 |
| public E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| public boolean remove(Object o) | 删除指定的元素，返回删除是否成功 |
| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
------代码展示-------
import java.util.ArrayList;
public class ArrayListDemo3 {
public static void main(String[] args) {
ArrayList<String> listString=new ArrayList<>();
listString.add("Java");
listString.add("Java");
listString.add("MySQL");
listString.add("HTML");
listString.add("MyBatis");
//1.public E get(int index): 获取某个索引位置处的元素值
String e = listString.get(3);
System.out.println(e);
//2.public int size(): 获取集合的大小(元素个数)
System.out.println(listString.size());
//3.完成集合的遍历
for (int i=0; i<listString.size(); i++){
System.out.println(listString.get(i));
}
/* for (String s : listString) { System.out.println(s); } */
//4.public E remove(int index): 删除指定索引处的元素，返回被删除的元素
System.out.println(listString);
String e2 = listString.remove(2);
System.out.println(e2);
System.out.println(listString);
//5.public boolean remove(Object o): 直接删除元素值，删除成功返回true，删除失败返回false
listString.remove("Java");
System.out.println(listString);
//6.public E set(int index,E element): 修改指定索引处的元素，返回被修改的元素
String e3 = listString.set(2,"MySql");
System.out.println(e3);
System.out.println(listString);
}
}
◆ ArrayList 集合案例：遍历并删除元素
import java.util.ArrayList;
/* 目标:学习遍历删除元素的正确方案 */
public class ArratListDemo4 {
public static void main(String[] args) {
ArrayList<Integer> listInteger = new ArrayList<>();
listInteger.add(79);
listInteger.add(87);
listInteger.add(100);
listInteger.add(97);
listInteger.add(73);
listInteger.add(80);
System.out.println(listInteger);
for (int i=0; i<listInteger.size(); i++){
int score = listInteger.get(i); //将索引值暂时存储在score中
if (score>=80){
System.out.println(score);
}else {
listInteger.remove(i);
i--; //删除成功后,必须退一步,这样可以保证下次回到这个位置,如此不会跳过数据
}
}
//重后面到这删除就可以
for (int i = listInteger.size()-1; i >=0 ; i--) {
int score = listInteger.get(i);
if (score>=80){
System.out.println(score);
}else {
listInteger.remove(i);
}
}
}
}
◆ ArrayList 集合案例：存储自定义类型的对象
/* 电影类 */
public class Movie {
//成员变量
private String File;
private double Score;
private String Name;
//构造
public Movie() { }
public Movie(String file, double score, String name) { File = file; Score = score; Name = name; }
//封装
public String getFile() { return File; }
public void setFile(String file) { File = file; }
public double getScore() { return Score; }
public void setScore(double score) { Score = score; }
public String getName() { return Name; }
public void setName(String name) { Name = name; }
}
import cn.ObjectOriental.MoviesShow.Movie;
import java.util.ArrayList;
/*
方法1：
需求：定义电影类（名称、分值、演员）,创建三个电影对象,代表影片,插入集合中遍历
"《长津湖》",9.8,"吴京"
"《我和我的父辈》",9.6,"吴京"
"《扑水少年》",9.5,"王川"
*/
public class ArrayListDemo5 {
public static void main(String[] args) {
/*1.定义电影类Movie*/
/*2.创建3个电影对象*/
Movie m1 = new Movie("《长津湖》",9.8,"吴京");
Movie m2 = new Movie("《我和我的父辈》",9.6,"吴京");
Movie m3 = new Movie("《扑水少年》",9.5,"王川");
/*3.创建一个电影对象的ArrayList集合,并存储电影对象*/
ArrayList<Movie> list = new ArrayList<>();
list.add(m1);
list.add(m2);
list.add(m3);
System.out.println(list); //此时list集合中存储的是指向电影对象的地址
/*4.遍历电影类型的集合中的每一个对象.访问它的信息即可*/
for (int i = 0; i < list.size(); i++) {
Movie m = list.get(i); //定义对象来接它遍历对象的地址
System.out.println("电影名称: "+m.getFile());
System.out.println("电影评分: "+m.getScore());
System.out.println("电影主演: "+m.getName());
}
}
}
import cn.ObjectOriental.MoviesShow.Movie;
import java.util.ArrayList;
/*
方法2：使用匿名对象
需求：定义电影类（名称、分值、演员）,创建三个电影对象,代表影片,插入集合中遍历
"《长津湖》",9.8,"吴京"
"《我和我的父辈》",9.6,"吴京"
"《扑水少年》",9.5,"王川"
*/
public class ArrayListDemo5 {
public static void main(String[] args) {
/*1.定义电影类Movie*/
/*2.创建3个电影对象*/
/*3.创建一个电影对象的ArrayList集合,并存储电影对象*/
ArrayList<Movie> list = new ArrayList<>();
list.add(new Movie("《长津湖》",9.8,"吴京"););
list.add(new Movie("《我和我的父辈》",9.6,"吴京"););
list.add(new Movie("《扑水少年》",9.5,"王川"););
System.out.println(list); //此时list集合中存储的是指向电影对象的地址
/*4.遍历电影类型的集合中的每一个对象.访问它的信息即可*/
for (int i = 0; i < list.size(); i++) {
Movie m = list.get(i); //定义对象来接它遍历对象的地址
System.out.println("电影名称: "+m.getFile());
System.out.println("电影评分: "+m.getScore());
System.out.println("电影主演: "+m.getName());
}
}
}
◆ ArrayList 集合案例：元素搜索
public class Student {
private String studyNumber; //学号
private String name; //姓名
private int age; //年龄
private String className; //教室
public Student() { }
public Student(String studyNumber, String name, int age, String className) {
this.studyNumber = studyNumber;
this.name = name;
this.age = age;
this.className = className;
}
public String getStudyNumber() { return studyNumber; }
public void setStudyNumber(String studyNumber) { this.studyNumber = studyNumber; }
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; }
public String getClassName() { return className; }
public void setClassName(String className) { this.className = className; }
}
import java.util.ArrayList;
import java.util.Scanner;
/* 案例:学生信息系统,显示数据,并按照学号完成搜索学生类信息
* 测试数据:
* "BI035gEYy","一叶孤城",22,"推理一班"
* "wqA90HQpU","东方延绪",26,"中医学四班"
* "0uzRxJv6o","西门吹雪",24,"法医系三班"
* "bUQqiml3Z","东梅超风",21,"精神科五班"
* "Uo7Hbykpb","西方不败",27,"修理学二班" */
public class ArrayListStudent {
public static void main(String[] args) {
//1.创建学生类
//2.创建学生对象封装学生对象
//把学生对象添加到集合中去
ArrayList<Student> liststudent = new ArrayList<>();
liststudent.add(new Student("BI035gEYy","一叶孤城",22,"推理一班" ));
liststudent.add(new Student("wqA90HQpU","东方延绪",26,"中医学四班"));
liststudent.add(new Student("0uzRxJv6o","西门吹雪",24,"法医系三班"));
liststudent.add(new Student("bUQqiml3Z","东梅超风",21,"精神科五班"));
liststudent.add(new Student("Uo7Hbykpb","西方不败",27,"修理学二班"));
//3.遍历变量集合中的每个信息并打印
System.out.println("学号"+"\t\t\t"+"姓名: "+"\t\t"+"年龄: "+"\t"+"班级: ");
for (int i = 0; i < liststudent.size(); i++) {
Student s = liststudent.get(i);
System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getClassName());
}
//4.定义方法按照学号查询学员信息
Scanner input=new Scanner(System.in);
while (true){
System.out.print("请输入学号查询对象: ");
String studyNumber = input.next();
//5.调用方法查询
Student s = getStudyId(liststudent,studyNumber);
//6.判断s中是否存在学生地址
if(s == null){
System.out.println("对不起,查无此人(￣▽￣)~*");
}else {
System.out.println("你查询的学生信息如下:");
System.out.println("学号"+"\t\t\t"+"姓名: "+"\t\t"+"年龄: "+"\t"+"班级: ");
System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getClassName()+"\n");
}
}
}
/* 根据学生的学号查询学生对象返回
* @param students 存储全部学生对象的集合
* @param studyNumber 搜索的学生对象的集合
* @return 学生对象 | null
* */
public static Student getStudyId(ArrayList<Student> liststudent,String studyNumber){
//1.遍历全部学生对象
for (int i = 0; i < liststudent.size(); i++) {
Student s = liststudent.get(i);
//2.询问当前遍历的这个学生的学号:是否我们要找的学号
if(s.getStudyNumber().equals(studyNumber)){
//这个s代表的学生对象,就是我们要找的,返回它
return s;
}
}
//查无此人
return null;
}
}
1899
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
