Java笔记–API 应用程序编程接口
Application Program Interface
概述
API(Application Programming Interface)，应用程序编程接口。Java API是—本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。
Scanner类
Scanner类是一个基本的文本扫描器，可以读出键盘输入的数据。
import java.util.Scanner;//1、导包
/*
Scanner类的功能：可以实现键盘输入数据，到程序当中。
引用类型的一般使用步骤
1.导包
import 包路径.名称
如果需要使用的目标类和当前类位于同一个包下，则可以省略不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。
2、创建
类名称 对象名 = new 类目名称();
3、使用
对象.成员方法名()
获取键盘输入的一个int数字：int num = sc.nextInt();
获取键盘输入的一个字符串：String str1 = sc.next();
*/
public class Demo01Scanner {
public static void main(String[] args) {
String str = "123";//java.lang不需要导包
//System.in代表从键盘进行输入
Scanner sc = new Scanner(System.in);
//获取从键盘输入的int数字
int num = sc.nextInt();
System.out.println("输入的数字是："+num);
//获取键盘输入的一个字符串
String str1 = sc.next();
System.out.println("输入的字符串是："+str1);
}
}
匿名对象
创建对象标准格式：
类名称 对象名 = new 类名称();
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符：
new 类名称();
【注意事项】匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
【使用建议】如果有一个对象确定只需要使用唯一的一次，就可以使用匿名对象。
public class Demo02Anonymous {
public static void main(String[] args) {
//左边的one就是对象的名字
Person one = new Person();
one.name = "小小";
one.showName();//我叫：小小
System.out.println("================");
//匿名对象
new Person().name = "大大";
new Person().showName();//我叫：null
}
}
//Person类
public class Person {
String name;
public void showName(){
System.out.println("我叫："+name);
}
}
使用匿名对象作为函数的参数和返回值
import java.util.Scanner;
public class Demo02Anonymous_2 {
public static void main(String[] args) {
/*
//普通方式
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
System.out.println("输入的是："+num);
//匿名对象的方式
int number = new Scanner(System.in).nextInt();
System.out.println(number);
*/
//使用一般写法 传入参数
Scanner sc = new Scanner(System.in);
methodParam(sc);
System.out.println("******************");
//使用匿名方法传递参数
methodParam(new Scanner(System.in));
Scanner sc1 = methodReturn();
int num = sc1.nextInt();
System.out.println("输入的是："+num);
}
//参数类型为Scanner
public static void methodParam(Scanner sc){
int num = sc.nextInt();
System.out.println("输入的是："+num);
}
//返回值类型为Scanner的类
public static Scanner methodReturn(){
return new Scanner(System.in);
}
}
Random类
Random类用来生成随机数字。使用起来也是三个步骤
1、导包
import java.until.Random
2、创建
Random r = new Random();
3、使用
获取一个随机的int数字（范围是int所有范围，有正负两种）
int num = r.nextInt();
获取一个随机的int数字（参数代表范围，左闭右开区间）
int num = r.nextInt(3);
实际上代表的含义是[0,3)，也就是0~2。
import java.util.Random;
public class Demo01Random {
public static void main(String[] args) {
Random r =new Random();
int num = r.nextInt();
System.out.println("随机数为："+num);
}
}
对象数组
/*
【题目】定义一个数组，用来存放3个Person对象。
数组有一个缺点：一旦创建程序运行期间长度不可发生改变。
*/
public class Demo01Array {
public static void main(String[] args) {
//首先创建一个长度为3的数组
Person[] array =new Person[3];
Person one = new Person("迪丽热巴",18);
Person two = new Person("古力娜扎",28);
Person three = new Person("哈妮克孜",38);
array[0]=one;//地址值
array[1]=two;
array[2]=three;
System.out.println(array[1].getName());
}
}
==ArrayList集合类==
数组的长度不可以发生改变。但是ArrayList集合的长度是可以随意变化的
对于ArrayList来说有一个
泛型：也就是装在集合中的所有元素都是什么类型
【注意】泛型只能是应用类型不能是基本类型
【注意事项】
- 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
- 如果内容为空，得到的是中括号：[ ]
import java.util.ArrayList;
public class Demo02ArrayList {
public static void main(String[] args) {
//创建了一个ArrayList集合，集合的名称是list，里面装的全都是String类型的数据
//备注：从JDK1.7开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写上的
ArrayList<String> list =new ArrayList<>();
System.out.println(list);
//向集合中添加一些数据，需要用到add方法
list.add("赵丽颖");
System.out.println(list);
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
System.out.println(list);
}
}ArrayList当中常用的方法有：
public boolean add(E e): 向集合当中添加元素，参数类型和泛型一致。
对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但是对于其他集合来说add添加动作不一定成功。
public E get(int index): 从集合当中获取元素，参数是索引编号返回值就是对应位置的元素。
public E remove(int index): 从集合中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size( ): 获取集合的尺寸长度，返回值是集合中包含的元素个数。
import java.util.ArrayList;
public class Demo03ArrayListMethod {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
System.out.println(list);//[]
//向集合中添加元素：add
boolean success = list.add("柳岩");
System.out.println(list);//柳岩
System.out.println("添加动作是否成功："+success);//tru
list.add("高圆圆");
list.add("蔡徐坤");
list.add("李小璐");
list.add("贾乃亮");
System.out.println(list);
//从集合中获取元素，get.索引值从0开始
String name = list.get(2);
System.out.println("第二号索引位置："+name);
//从集合中删除元素，remove.索引从0开始
String whoRemove = list.remove(4);
System.out.println(whoRemove+"被绿了");
System.out.println(list);
//获取集合的长度尺寸，也就是其中的元素个数
int size = list.size();
System.out.println("集合大小："+size);
}
}
遍历集合
import java.util.ArrayList;
public class Demo04ArrayListEach {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("玛玛哈哈");
//遍历集合
for (int i = 0; i <list.size() ; i++) {
System.out.println(list.get(i));
}
}
}
基本类型与包装类型
如果希望相机和Arraylist当中存储基本类型，必须使用基本类型对应的”包装类“。
基本类型 包装类型(引用类型，包装类都位于java.long包下)
| 基本类型 | 包装类型 | 注意 |
|---|---|---|
| byte | Byte | |
| short | Short | |
| int | Integer | 【特殊】 |
| long | Long | |
| float | Float | |
| double | Double | |
| char | Character | 【特殊】 |
| boolean | Boolean |
- 从JDK1.5+开始，支持自动装箱、自动拆箱。
自动装箱:基本类型–>包装类型
自动拆箱:包装类型–>基本类型
import java.util.ArrayList;
public class Demo05ArrayListBasic {
public static void main(String[] args) {
ArrayList<String> listA = new ArrayList<>();
//错误写法：泛型只能是引用类型，不能使用基本类型
//ArrayList<int> listB = new ArrayList<>();
ArrayList<Integer> listC = new ArrayList<>();
listC.add(10);
listC.add(20);
System.out.println(listC);
int A = listC.get(1);
System.out.println(A);
}
}
字符串
java. Lang. String类代表字符串。
API当中说: Java程序中的所有字符串字面值(如”abc” )都作为此类的实例实现。
其实就是说:程序当中所有的双引号字符串，都是String类的对象。(就算没有new, 也照样是。)
【字符串的特点】
- 字符串的内容永不可变。 [重点]
- 正是因为字符串不可改变，所以字符串是可以共享使用的。
- 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。
创建字符串的常见3+1种方式。
三种构造方法:
- public String( ): 创建一个空白字符串，不含有任何内容。
- public String(char[] array): 根据字符数组的内容，来创建对应的字符串。
- public. String(byte[] array): 根据字节数组的内容，来创建对应的字符串。
一种直接创建:
注意：直接写上双引号就是字符串对象。
public class Demo01String {
public static void main(String[] args) {
//使用空参构造
String str1 = new String(); //小括号留空，说明字符串什么内容都没有T
System. out. println("第1个字符串:"+ str1);
//根据字符数组创建字符串
char[] charArray = { 'A', 'B', 'C' };
String str2 = new String(charArray) ;
System. out. println("第2个字符串:"+ str2);
//根据字节数组创建字符串
byte[] byteArray = { 97, 98, 99 };
String str3 = new String(byteArray) ;
System. out . println("第3个字符串:" + str3);
//直接创建
String str4 = "Hello";
System.out.println("第4个字符串:" + str4);
}
}
常量池
双引号直接定义的在常量池当中，new的对象不在常量池当中
/*
字符串常量池:程序当中直接写.上的双引号字符串，就在字符串常量池中。
对于基本类型来说，==是进行数值的比较。
对于引用类型来说，==是进行【地址值】的比较。
*/
public class Demo02StringPool {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
char[] charArray = {'a', 'b', 'c'};
String str3 = new String(charArray);
System.out.println(str1 == str2);//true
System.out.println(str1 == str3);//false
System.out.println(str2 == str3);//false
}
}双引号直接定义的对象在堆中先生成存储空间，再在“常量池空间”中存储，二者的初始化值相同，则指向常量池中相同的地址值。
由于new的对象不在常量池当中，而是在堆中新开辟了一块区域，所以二者的地址值不同。
字符串中的常用方法
字符串比较方法
== 是对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：
==public boolean equals(Object obj);==
参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给一个true,否则返回false
【注意事项】
- 任何对象都能用object进行接收。
- equals方法具有对称性，也就是a. equals(b)和b. equals(a)效果- 样。
- 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐: “abc”. equals(str)
不推荐: str. equals( “abc”)
==public boolean equalsIgnoreCase(String str);==
忽略大小写，进行内容比较。
package cn.cikeshijia.Demo02;
public class Demo01StringEquals {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
char[] ch = {'a','b','c'};
String str3 = new String(ch);
System.out.println(str1.equals(str2));//true
System.out.println(str2.equals(str3));//true
System.out.println(str3.equals("abc"));//true
System.out.println("abc".equals(str2));//true
String str4 ="ABC";
System.out.println(str1.equals(str4)); // false
System.out.println("==============");
String str5 = null;
System.out.println("abc" . equals(str5)); //推荐:false
//System.out.println(str5. equals("abc")); //不推荐:报错，空指针异常NullPointerException
System.out.println("==============");
String strA = "Java" ;
String strB = "java" ;
System.out.println(strA. equals(strB)); // false,严格区分大小写
System.out.println(strA. equalsIgnoreCase(strB)); // true, 忽略大小写
//注意，只有英文字母区分大小写，其他都不区分大小写
System. out . println("abc一123" . equalsIgnoreCase( "abc壹123")); // false
}
}
字符串获取方法
public int length():
获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str):
将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index):
获取指定索引位置的单个字符。(索引从0开始)
public int indexOf(String str):
查找参数字符串在本字符串当中首次出现的索引位置,如果没有返回-1值。
public class Demo02StringGet {
public static void main(String[] args) {
//获取字符串的长度
int length = "jasfdiasfoijuwoerfjvb".length();
System.out.println("字符串的长度是：" + length);
//拼接字符串
String str1 = "Hello";
String str2 = "World";
String str3 = str1.concat(str2);
System.out.println("str1:"+str1);//Hello
System.out.println("str2:"+str2);//World
System.out.println("str3:"+str3);//HelloWorld.新字符串
System.out.println("====================");
//获取指定位置索引的单个字符
char ch = "Hello".charAt(2);
System.out.println("在2号索引位置的字符是："+ch);
System.out.println("===================");
//查找参数字符串在本来字符串当中出现的第-次索引位置
//如果根本没有，返回-1值
String original = "Hel1oWorldHelloWorld" ;
int index = original. indexOf("llo");
System. out. println("第一次索引值是:"+ index); // 2
System.out.println("HelloWorld".indexOf("abc"));
}
}
字符串截取方法
public String substring(int index):
截取从参数位置一直到字符串末尾, 返回新字符串。
public String substring(int begin, int end):
截取从begin开始， 一直到end结束，中间的字符串。
【备注】[begin,end), 包含左边，不包含右边。
public class Demo03Substring {
public static void main(String[] args) {
String str1 = "HelloWorld" ;
String str2 = str1. substring(5);
System.out.println(str1); // HelloWorld,原封不动
System.out.println(str2); // World, 新字符串
System.out.println("============");
String str3 = str1. substring(4,7);
System.out.println(str3);//oWo
System.out.println("============");
//下面这种写法，字符串的内容仍然是没有改变的
//下面有两个字符串，"Hello", "Java"
// strA当 中保存的是地址值。
//本来地址值是Hello的ex666,
//后来地址值变成了Java的0x999
String strA = "He11o";
System. out. println(strA); // Hello
strA = "Java";
System. out . println(strA); // Java
}
}
字符串转换方法
String当中与转换相关的常用方法有:
public char[] toCharArray():
将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes():
获得当前字符串底层的字节数组。
public. String replace(CharSequence oldstring,. CharSequence newString):
将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
public class Demo04StringConvert {
public static void main(String[] args) {
//转换成为字符数组
char[] chars = "He11o". toCharArray() ;
System. out. println(chars[0]); // H
System. out . println(chars.length); // 5
System. out . println("=============");
//转换成为字节数组
byte[] bytes = "abc" . getBytes();
for (int i = 0; i < bytes. length; i++) {
System.out. println(bytes[i]);
}
System. out . println("=============");
//字符串的内容替换
String str1 = "How do you do?";
String str2 = str1. replace( "o","*");
System. out . println(str1); // How do you do?
System. out. println(str2); // H*w d* y*u d*?
System. out . println("============");
String lang1 = "会不会玩儿呀!你大爷的!你大爷的!你大爷的! ! ! ";
String lang2 = lang1 . replace("你大爷的","****");
System. out . println(lang2); //会不会玩儿呀! ******** *** ! !
}
}
字符串分割方法
分割字符串的方法:
public String[] split(String regex):
按照参数的规则，将字符串切分成若干部分。
注意事项:
split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意:如果按照英文句点“.”进行切分，必须写”\.” (两个反斜杠)
public class Demo05StringSplit { public static void main(String[] args) { String str1 = "aaa,bbb,ccc"; String[] array1 = str1.split(","); for (int i = 0; i < array1.length;i++){ System.out.println(array1[i]); } System.out.println("==========="); String str2 = "aaa bbb ccc"; String[] array2 = str2.split(" "); for (int i = 0; i < array2.length; i++) { System.out. println(array2[i]); } System. out. println("============"); String str3 = "XXX.YYY .ZZZ" ; String[] array3 = str3.split("\\."); System. out . println(array3.length); // 3 for (int i = 0; i < array3.length; i++) { System.out.println(array3[i]); } } }
```
