Java基础内容 ---- API文档，基础类（Scanner类，Random类，ArrayList类，String类，Arrays类，Math类）
API文档（Java API）理解概述：
JDK里已经写好的类可以直接调用无需再手动编写，API文档相当于JDK中已经编好的类的“字典”。
API(Application Programming Interface，应用程序编程接口)的使用概述:
在API文档中搜索已经被写好的类；读取关键信息：类的包名，构造方法，一般方法；关键信息运用到编程：先申明导入，再在主方法中像自已写的类一样的使用构造方法和一般方法。
基础类的理解概述：
JDK已经写好的常用的几个类包括：Scanner类，Random类，ArrayList类，String类，Arrays类，Math类。
- java.util.Scanner类是解析基本类型和字符串的文本扫描器，有构造方法从键盘录入上述数据类型，有一般方法判断键盘是否录入了某种数据，返回键盘录入的某种数据。
- java.util.Random类是随机数生成器，有构造方法随机生成数，有一般方法返回0--指定n中均匀分布的整数，0.0--1.0中均匀分布的double型，float型等。
- java.util.ArrayList类是大小可变的，可存储不同类型对象的集合（类比长度固定，可存储基本数据类型，同一类型对象），有构造方法新建内容为空的集合，有一般方法对集合元素增，删，查，获取长度。
- java.lang.String类是字符串类，实际上，任何字符串常量都可以视为JVM自动new的一个字符串对象，JVM把这种对象存储在字符串常量池中，并且相同的字符串常量能共享内存地址。容易混淆的是：字符串类有构造方法new字符串对象，这种新建方式将对象存储在字符串常量池外，不论初始字符串是否相同都不能共享地址。另有一般方法比较字符串内容，搜索字符串中某一字符的索引，提取字符串索引上的字符等。因为用到字符串的地方最多，所以对应的方法也最多。
- java.utli.Arrays类是数组类，有静态方法将数组转换成字符串，对int型数组升序排序。静态方法可以直接用Arrays.方法名（）调用。
- java.lang.Math类是基本数学运算类，有静态方法实现初等指数，对数，平方根，三角函数，都是直接用Math.方法名（）调用。
基础类的使用概述：
- 和自己写的模拟客观世界的类的使用步骤一样；无非就是构造方法，一般方法不能直接在实际生活中找到客观对应，所以不好直接理解着使用；看文档了解基本作用写测试代码测试一下功能就很直观了。
- 不难察觉，Java中已经实现的类和方法很多，每个方法的关键信息包含方法功能，返回类型，方法名，方法参数，信息繁多于是需要简化记忆：只要记住方法名，根据功能可以推出返回值，IDEA打出方法名有参数提示。为了恰到好处地运用到这些现成的方法，提高熟练度的方法有：随时查阅API文档尽量使用，每次使用都把关键信息与功能对应增强逻辑，英文单词也可以增强逻辑。
Scanner类最终测试代码：
import java.util.Scanner;
//import 包名.类名;
//java.lang包无需导入
public class specialClass {
public static void main(String[] args) {
//1.1 用Scanner类方法获取，返回键盘输入数据
Scanner sc = new Scanner(System.in);
//System.in为参数的构造方法最最常用
int i = sc.nextInt();
System.out.println(i);
//double i = sc.nextDouble;
//float i = sc.nextFloat;
//short i = sc.nextShort;
//byte i = sc.nextByte;
//boolean i = sc.nextBoolean;
//
//next(),nextLine()都能返回键盘输入的字符串，但稍有不同
System.out.println("next()只能读取到空格");
String a = sc.next();
System.out.println(a);
System.out.println("nextLine()能读到回车");
String b = sc.nextLine();
System.out.println(b);
//----------------------------------------------------------
//1.2 sc.hasNextXxx()系列用于判断是否有该类型输入
System.out.println("请输入你的姓名");
String name = sc.nextLine();
System.out.println("请输入你的ID");
String ID;
while (sc.hasNextLine()) {
// hasNextLine()方法判断当前是否有输入，当键盘有输入后执行循环
if (sc.hasNextInt()) {
// 判断输入的值是否为整数类型，当为整数类型时执行分支语句
ID = sc.nextLine();
System.out.println("你输入的姓名为：" + name);
System.out.println("你输入的ID为：" + ID);
break;
} else {
System.out.println("请输入数字哦！");
ID = sc.nextLine();
System.out.println("此时从键盘上获取的ID为"+ID+"但是循环继续");
continue;
}
}
//
//凡是属于IO流的类如果不关闭就会一直占用资源，要养成好习惯用完就关掉
sc.close();
}
}
Random类最终测试代码：
package com.baishi.stage1.day07;
import java.util.Random;
//java.lang.Math.Random类中含有Math.Random()
public class randomCode {
public static void main(String[] args) {
//1.1 非实例方法，实例方法产生随机数
double c =Math.random(); //java.lang包下不需实例，直接用[0.0,1.0)近似均匀分布随机,不可设置上界
System.out.println(c);
//
Random random = new Random(); //无参数构造方法默认当前系统时间的毫秒数作为种子数
int a = random.nextInt(); //[-2^31,2^31)均匀分布随机
System.out.println(a);
//double a = random.nextDouble(); [0.0,1.0)均匀分布随机,不可设置上界
//float a = random.nextFloat(); 同上
//Boolean a = random.nextBoolean(); false/true均匀分布随机
//
int b = random.nextInt(100);//[0,自定义上界)均匀分布随机
System.out.println(b);
//int b = random.double()*double n+double m [0.0,n+m)均匀分布随机
//---------------------------------------------------------------------
//1.2 对于种子相同的Random对象，生成的随机数序列是一样的
Random random1 = new Random(10);
System.out.println("使用种子为10的Random1对象生成[0,10)内随机整数序列: ");
for (int i = 0; i < 10; i++) {
System.out.print(random1.nextInt(10) + " ");
}
System.out.println();
Random ran2 = new Random(10);
System.out.println("使用种子为10的Random2对象生成[0,10)内随机整数序列: ");
for (int i = 0; i < 10; i++) {
System.out.print(ran2.nextInt(10) + " ");
}
}
}
0.22580207843298905
1944166365
20
使用种子为10的Random1对象生成[0,10)内随机整数序列:
3 0 3 0 6 6 7 8 1 4
使用种子为10的Random2对象生成[0,10)内随机整数序列:
3 0 3 0 6 6 7 8 1 4
ArrayList类最终测试代码：
package com.baishi.stage1.day07;
import java.util.ArrayList;
import java.util.Random;
class Goods {
private String brand;
private Double price;
public Goods() {
}
public Goods(String brand, Double price) {
this.brand = brand;
this.price = price;
}
}
public class arrayListCode {
public static void main(String[] args) {
Goods hotDog = new Goods("Tom's", 1.5);
Goods hamBurger = new Goods("KFC", 10.0);
//1.1集合添加对象，集合中操作对象
ArrayList<Goods> list1 = new ArrayList<Goods>(); //无参数方法构造一个内容为空的集合
//ArrayList<String> list = new ArrayList<String>();
//
//对元素增，删，查
list1.add(hotDog); //将元素添加到集合的尾部
list1.add(hamBurger);
System.out.println("增：" + list1);
//list.add(E e); 添加的元素e的类型E与ArrayList<E>对应
//
Goods a = list1.remove(0); //删除指定索引的元素，返回被删除的元素
System.out.println("删：" + a + "其余元素索引上提");
Goods b = list1.get(0); //返回指定位置上的元素
System.out.println("查：" + b);
//
//依照集合元素数，自定义格式遍历打印集合，规避了越界
int list1Size = list1.size();//返回集合中的元素
for (int i = 0; i < list1Size; i++) {
System.out.println("***" + list1.get(i) + "***");
}
}
}
增：[com.baishi.stage1.day07.Goods@1b6d3586, com.baishi.stage1.day07.Goods@4554617c]
删：com.baishi.stage1.day07.Goods@1b6d3586其余元素索引上提
查：com.baishi.stage1.day07.Goods@4554617c
***com.baishi.stage1.day07.Goods@4554617c***
import java.util.ArrayList;
import java.util.Random;
public class arrayListCode1 {
public static void main(String[] args) {
//1.2数组类定长，集合类不定长
int[] arr = new int[20];
ArrayList<Integer> list2 = new ArrayList<Integer>();
//ArrayList对象只能存储引用类型数据，<int>错误
//ArrayList<Character> list2 = new ArrayList<int>();
//ArrayList<Double> list2 = new ArrayList<double>();
//除了Integer和Character，其他基本类型包装类都是基本类型首字母大写
//
// 添加随机数到数组，集合
Random random = new Random();
int count = 0;
for (int i = 0; i < 20; i++) {
int r = random.nextInt(1000) + 1;
arr[i] = r;
if (r % 2 == 0) {
count++;//对于偶数元素需要计数为小数组定长
}
}
for (int i = 0; i < 20; i++) {
int r = random.nextInt(1000) + 1;
list2.add(r);
}
//
// 创建定长小数组，小集合来保存偶数
int[] smallArr = new int[count];
for (int i = 0, j = 0; j < arr.length; j++) {
if (arr[j] % 2 == 0) {
smallArr[i] = arr[j];
i++;
}
}
ArrayList<Integer> smallList = new ArrayList<>();
for (int i = 0; i < list2.size(); i++) {
Integer num = list2.get(i);
if (num % 2 == 0) {
smallList.add(num);
}
}
//
// 打印小数组，小集合
System.out.println("保留偶数的小数组需要时刻注意索引不越界");
for (int i = 0; i < smallArr.length; i++) {
System.out.print(smallArr[i] + " ");
}
System.out.println();
System.out.println("保留偶数的小集合不需要时刻注意索引不越界");
System.out.println(smallList);
}
}保留偶数的小数组需要时刻注意索引不越界
790 734 96 820 264 718 834 92 480 516
保留偶数的小集合不需要时刻注意索引不越界
[930, 272, 112, 116, 246, 852, 672, 750, 944, 550, 796, 166]
String类最终测试代码：
public class stringCode {
public static void main(String[] args) {
//1.1 直接赋值是JVM new的对象,与自己new的对象具有内存上的区别.
String str1 = "abc";
String str2 = "abc";
char[] chars = {'a', 'b', 'c'};
String str3 = new String("abc");
//String str = new String(); str = "abc";
//byte bytes[] = {97,98,99}; String str = new String(bytes);
//任何对象的地址都能追溯到字节数组的内存地址
//
if(str1 == str2) System.out.println(true);
else System.out.println(false);//true,说明:直接赋值,相同字符串常量地址可以共享
if(str2 == str3) System.out.println(true);
else System.out.println(false);//false,说明:手动new总是新建内存地址,不会因为初始字符串相同而共享"
}
}内存图说明：
public class stringCode {
public static void main(String[] args) {
//1.2boolean equals(Object)与boolean equalsIgnoreCase(String)都是比较字符串内容是否相同，但稍有不同.
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
// --------------------------------------------------------------------------
//1.3String类中与获取相关的一般方法的关键信息
// length()获取字符串的长度
int length = "asdasfeutrvauevbueyvb".length();
//concat()获取拼接字符串
String str1 = "Hello".concat("World");
System.out.println(str1);//HelloWorld
//charAt()获取指定索引位置的单个字符
char ch = "Hello".charAt(1);//e
//indexOf() 获取参数字符串在本来字符串当中出现的第一次索引位置
// 如果根本没有，返回-1值
int index = "HelloWorld".indexOf("llo");
System.out.println("第一次索引值是：" + index); //第一次索引值是：2
System.out.println("HelloWorld".indexOf("abc"));//-1
//substring(int index) 获取从参数位置一直到字符串末尾，返回新字符串。
String str2 = "HelloWorld".substring(5);
System.out.println(str2); //World
//String substring(int begin, int end)：获取[begin，end)中间的字符串
String str3 = "HelloWorld".substring(4, 7);
System.out.println(str3); //oWo
}
}
//1.4 String类中与转换相关的一般方法的关键信息
// char[] toCharArray()转换成为字符数组
char[] chars = "Hello".toCharArray();
// byte[] getBytes() 转换成为字节数组
byte[] bytes = "abc".getBytes();
// String replace(CharSequence oldString, CharSequence newString)字符串的内容替换
String str1 = "How do you do?";
String str2 = str1.replace("do", "**");
System.out.println(str1); // How do you do?
System.out.println(str2); // H*w ** you **?
//-------------------------------------------------------------
//1.5String类关于切割的一般方法
//按照参数将字符串分割成不同的子字符串,存储在字符串数组里
String str1 = "aaa,bbb,ccc";
String[] array1 = str1.split(",");
//
//注意:英文句点用"\\."表示
String str3 = "XXX.YYY.ZZZ";
String[] array3 = str3.split("\\.");
Arrays类最终测试代码:
import java.util.Arrays;
public class stringCode {
public static void main(String[] args) {
//1.1使用Arrays类静态方法的关键信息
//toString()将数组内容转换为字符串
int[] arr = {5,4,3,2,1};
String s = Arrays.toString(arr);
System.out.println(s); //[5, 4, 3, 2, 1]
//对int型数组进行升序排序
System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5]
}
}
Math类最终测试代码：
public class stringCode {
public static void main(String[] args) {
//1.1 使用Math类的关键信息
//abs()返回参数绝对值
double a = Math.abs(-5); //5
//ceil() 返回大于等于参数的最小整数
double b = Math.ceil(-5.5); //-5.0
//floor()返回最接近参数的long（相当于四舍五入法）
double c = Math.round(5.5); //6.0
double d = Math.round(5.4); //5.0
}
}
扫一扫
1241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
