一，常用API（一）
API：
API(Application Programming Interface)，应用程序编程接口。
意思就是说这个是Java的开发人员早就定义好的类，我们只需要用哪个查那个，调用就行
如果不懂某个接口或者类，可以通过API文档搜索进行查看.
1.Scanner类，Random类，Arraylist类
1.1，Scanner 一个可以解析基本类型和字符串的简单文本扫描器。
例如，以下代码使用户能够从
System.in 中读取一个数：
通俗来将就是将你从控制台输入的数据，进行保存。
常用方法: nextInt() ：将输入信息的下一个标记扫描为一个 int 值。
注意：1.2.3. ....是使用步骤
1 package cn.itcast.day07.demo01; 2 3 import java.util.Scanner; // 1. 导包 4 5 /* 6 Scanner类的功能：可以实现键盘输入数据，到程序当中。 7 8 引用类型的一般使用步骤： 9 10 1. 导包 11 import 包路径.类名称; 12 如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。 13 只有java.lang包下的内容不需要导包，其他的包都需要import语句。 14 15 2. 创建 16 类名称 对象名 = new 类名称(); 17 18 3. 使用 19 对象名.成员方法名() 20 21 获取键盘输入的一个int数字：int num = sc.nextInt(); 22 获取键盘输入的一个字符串：String str = sc.next(); 23 */ 24 public class Demo01Scanner { 25 26 public static void main(String[] args) { 27 // 2. 创建 28 // 备注：System.in代表从键盘进行输入 29 Scanner sc = new Scanner(System.in); 30 31 // 3. 获取键盘输入的int数字 32 int num = sc.nextInt(); 33 System.out.println("输入的int数字是：" + num); 34 35 // 4. 获取键盘输入的字符串 36 String str = sc.next(); 37 System.out.println("输入的字符串是：" + str); 38 } 39 40 }
1.2，Random 此类的实例用于生成伪随机数
生成随机数
常用方法： nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和 指定值 n
（不包括）之间的int 值。
1 import java.util.Random; 2 3 /* 4 Random类用来生成随机数字。使用起来也是三个步骤： 5 6 1. 导包 7 import java.util.Random; 8 9 2. 创建 10 Random r = new Random(); // 小括号当中留空即可 11 12 3. 使用 13 获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt() 14 获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3) 15 实际上代表的含义是：[0,3)，也就是0~2 16 */ 17 public class Demo01Random { 18 19 public static void main(String[] args) { 20 Random r = new Random(); 21 22 int num = r.nextInt(); 23 System.out.println("随机数是：" + num); 24 } 25 26 }
1.3，Arraylist 对象数组
常用方法： 增删改查
add(E e) ：将指定的元素添加到此集合的尾部。
remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
例子
import java.util.ArrayList; /* ArrayList当中的常用方法有： public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。 备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。 但是对于其他集合（今后学习）来说，add添加动作不一定成功。 public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。 public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。 public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。 */ 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); // true list.add("高圆圆"); list.add("赵又廷"); list.add("李小璐"); list.add("贾乃亮"); System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮] // 从集合中获取元素：get。索引值从0开始 String name = list.get(2); System.out.println("第2号索引位置：" + name); // 赵又廷 // 从集合中删除元素：remove。索引值从0开始。 String whoRemoved = list.remove(3); System.out.println("被删除的人是：" + whoRemoved); // 李小璐 System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 贾乃亮] // 获取集合的长度尺寸，也就是其中元素的个数 int size = list.size(); System.out.println("集合的长度是：" + size); } }
使用步骤
1 import java.util.ArrayList; 2 3 /* 4 数组的长度不可以发生改变。 5 但是ArrayList集合的长度是可以随意变化的。 6 7 对于ArrayList来说，有一个尖括号<E>代表泛型。 8 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。 9 注意：泛型只能是引用类型，不能是基本类型。 10 11 注意事项： 12 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。 13 如果内容是空，得到的是空的中括号：[] 14 */ 15 public class Demo02ArrayList { 16 17 public static void main(String[] args) { 18 // 创建了一个ArrayList集合，集合的名称是list，里面装的全都是String字符串类型的数据 19 // 备注：从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。 20 ArrayList<String> list = new ArrayList<>(); 21 System.out.println(list); // [] 22 23 // 向集合当中添加一些数据，需要用到add方法。 24 list.add("赵丽颖"); 25 System.out.println(list); // [赵丽颖] 26 27 list.add("迪丽热巴"); 28 list.add("古力娜扎"); 29 list.add("玛尔扎哈"); 30 System.out.println(list); // [赵丽颖, 迪丽热巴, 古力娜扎, 玛尔扎哈] 31 32 // list.add(100); // 错误写法！因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行 33 } 34 35 }
尖括号<E>代表泛型
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。 2.String类、static关键字、Arrays类、Math类
2.1，String 字符串
常用方法：equals 将此字符串与指定对象进行比较。
equalsIgnoreCase 将此字符串与指定对象进行比较，忽略大小写。
length () ：返回此字符串的长度。
concat (String str) ：将指定的字符串连接到该字符串的末尾。.
charAt (int index) ：返回指定索引处的 char值。
indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到
字符串结尾。
substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
endIndex截取字符串。含beginIndex，不含endIndex。
toCharArray () ：将此字符串转换为新的字符数组。
getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
replace (CharSequence target, CharSequence replacement) ：将与target匹配的
字符串使用replacement字符串替换。
/* java.lang.String类代表字符串。 API当中说：Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。） 字符串的特点： 1. 字符串的内容永不可变。【重点】 2. 正是因为字符串不可改变，所以字符串是可以共享使用的。 3. 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。 创建字符串的常见3+1种方式。 三种构造方法： public String()：创建一个空白字符串，不含有任何内容。 public String(char[] array)：根据字符数组的内容，来创建对应的字符串。 public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。 一种直接创建： String str = "Hello"; // 右边直接用双引号 注意：直接写上双引号，就是字符串对象。 */ public class Demo01String { public static void main(String[] args) { // 使用空参构造 String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。 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); } }
2.2，Static 静态
用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。
静态方法：使用static关键字修饰成员方法，称为静态方法,静态方法先执行
注意事项：
静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以
直接访问类变量或静态方法。
静态方法中，不能使用this关键字。
小贴士：静态方法只能访问静态成员。
/* 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。 如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。 静态变量：类名称.静态变量 静态方法：类名称.静态方法() 注意事项： 1. 静态不能直接访问非静态。 原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。 “先人不知道后人，但是后人知道先人。” 2. 静态方法当中不能用this。 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。 */ public class Demo02StaticMethod { public static void main(String[] args) { MyClass obj = new MyClass(); // 首先创建对象 // 然后才能使用没有static关键字的内容 obj.method(); // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。 obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名” MyClass.methodStatic(); // 正确，推荐 // 对于本来当中的静态方法，可以省略类名称 myMethod(); Demo02StaticMethod.myMethod(); // 完全等效 } public static void myMethod() { System.out.println("自己的方法！"); } }
静态内存图
2.3，Arrays 操作数组
常用方法：排序和搜索
toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。
import java.util.Arrays; /* java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。 备注： 1. 如果是数值，sort默认按照升序从小到大 2. 如果是字符串，sort默认按照字母升序 3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习） */ public class Demo01Arrays { public static void main(String[] args) { int[] intArray = {10, 20, 30}; // 将int[]数组按照默认格式变成字符串 String intStr = Arrays.toString(intArray); System.out.println(intStr); // [10, 20, 30] int[] array1 = {2, 1, 3, 10, 6}; Arrays.sort(array1); System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10] String[] array2 = {"bbb", "aaa", "ccc"}; Arrays.sort(array2); System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc] } }
2.4，Math 基本数***算
常用方法：
abs(double num)：获取绝对值。有多种重载。
ceil(double num)：向上取整。
floor(double num)：向下取整。
round(double num)：四舍五入。
/* java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数***算相关的操作。 Math.PI代表近似的圆周率常量（double）。 */ public class Demo03Math { public static void main(String[] args) { // 获取绝对值 System.out.println(Math.abs(3.14)); // 3.14 System.out.println(Math.abs(0)); // 0 System.out.println(Math.abs(-2.5)); // 2.5 System.out.println("================"); // 向上取整 System.out.println(Math.ceil(3.9)); // 4.0 System.out.println(Math.ceil(3.1)); // 4.0 System.out.println(Math.ceil(3.0)); // 3.0 System.out.println("================"); // 向下取整，抹零 System.out.println(Math.floor(30.1)); // 30.0 System.out.println(Math.floor(30.9)); // 30.0 System.out.println(Math.floor(31.0)); // 31.0 System.out.println("================"); System.out.println(Math.round(20.4)); // 20 System.out.println(Math.round(10.5)); // 11 } }
二，常用API（二）
Object类，Date类，DateFormat类，Calendar类，System类，StringBuilder类
1，Object类：是Java语言的根类（java.lang.Object）也就是父类超类
public class MyClass /*extends Object*/ { // ... }
常用方法：
public class Person { private String name; private int age; @Override //检查重写 public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } // 省略构造器与Getter Setter }
equals方法
import java.util.Objects; public class Person { private String name; private int age; @Override public boolean equals(Object o) { // 如果对象地址一样，则认为相同 if (this == o) return true; // 如果参数为空，或者类型信息不一样，则认为不同 if (o == null || getClass() != o.getClass()) return false; // 转换为当前类型 Person person = (Person) o; // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果 return age == person.age && Objects.equals(name, person.name); } }
2，Objects类:
提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象
public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); }
3，Date: 表示特定的瞬间，精确到毫秒。
构造方法
-
-
public Date(long date)
示例
import java.util.Date; public class Demo01Date { public static void main(String[] args) { // 创建日期对象，把当前的时间 System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018 // 创建日期对象，把当前的毫秒值转成日期对象 System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970 } }
小提醒：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。
常用方法：
public long getTime() 获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time) 设置时间，给的是毫秒值
示例
public class DateDemo02 { public static void main(String[] args) { //创建日期对象 Date d = new Date(); //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值 // System.out.println(d.getTime()); // System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 +"年"); //public void setTime(long time):设置时间，给的是毫秒值 // long time = 1000*60*60; long time = System.currentTimeMillis(); d.setTime(time); System.out.println(d); } }
构造方法
public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat使用给定的模式和默认的日期格式
格式如下：
| 标识字母（区分大小写） | 含义 |
| y | 年 |
| M | 月 |
| d | 日 |
| H | 时 |
| m | 分 |
| s | 秒 |
常用方法
格式化(从Date到String) public final String format(Date date)：将日期格式化成日期/时间字符串
解析(从String到Date) public Date parse(String source)：从给定字符串的开始解析文本以生成日期
示例
public class SimpleDateFormatDemo { public static void main(String[] args) throws ParseException { //格式化：从 Date 到 String Date d = new Date(); // SimpleDateFormat sdf = new SimpleDateFormat();创建日期格式 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); //调用format方法，格式化日期按照SimpleDateFormat定义的格式 String s = sdf.format(d); System.out.println(s); System.out.println("--------"); //从 String 到 Date String ss = "2048-08-09 11:11:11"; //ParseException 创建日期格式 SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //调用parse方法，解析字符串，生成日期 Date dd = sdf2.parse(ss); System.out.println(dd); } }
5，Calendar类 日历类
静态方法
public void set(int field, int value)：将给定的日历字段设置为给定值。
public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime()
示例一： set/get方法
import java.util.Calendar; public class CalendarUtil { public static void main(String[] args) { // 创建Calendar对象 Calendar cal = Calendar.getInstance(); // 设置年 int year = cal.get(Calendar.YEAR); // 设置月 int month = cal.get(Calendar.MONTH) + 1; // 设置日 int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH); //打印输出 System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); } } import java.util.Calendar; public class Demo07CalendarMethod { public static void main(String[] args) { //创建Calendar对象 Calendar cal = Calendar.getInstance(); //调用set方法，设置年 cal.set(Calendar.YEAR, 2020); //打印输出 System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2020年1月17日 } }
示例二： add方法
import java.util.Calendar; public class Demo08CalendarMethod { public static void main(String[] args) { //创建Calendar对象，getInstance使用默认时区和语言环境获得一个日历 Calendar cal = Calendar.getInstance(); System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日 // 使用add方法 cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天 cal.add(Calendar.YEAR, -3); // 减3年 System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; } }
示例三： getTime方法
import java.util.Calendar; import java.util.Date; public class Demo09CalendarMethod { public static void main(String[] args) { //创建Calendar对象，getInstance使用默认时区和语言环境获得一个日历 Calendar cal = Calendar.getInstance(); //getTime,Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象 Date date = cal.getTime(); System.out.println(date); // Tue Jan 16 16:03:09 CST 2021 } }
注意事项：
不要问为什么，因为Java语言是外国人发明的
在Calendar类中，月份的表示是以0-11代表1-12月。
-
-
-
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
-
示例一 currentTimeMillis方法
//验证for循环打印数字1-9999所需要使用的时间（毫秒） public class SystemTest1 { public static void main(String[] args) { //长整数型long，使用该方法 long start = System.currentTimeMillis(); //循环打印1-9999. for (int i = 0; i < 10000; i++) { System.out.println(i); } //长整数型long，使用该方法 long end = System.currentTimeMillis(); //输出结果 System.out.println("共耗时毫秒：" + (end - start)); } }
示例二 arraycopy方法
参数列表
import java.util.Arrays; public class Demo11SystemArrayCopy { public static void main(String[] args) { //定义一个数组 int[] src = new int[]{1,2,3,4,5}; int[] dest = new int[]{6,7,8,9,10}; //原数组不变，复制原数组中序列号从0到3的数， //到目标数组序列号0都3.目标数组发生变化 System.arraycopy( src, 0, dest, 0, 3); /*代码运行后：两个数组中的元素发生了变化 src数组元素[1,2,3,4,5] dest数组元素[1,2,3,9,10] */ } }
7，StringBuilder类 一个可变的字符串类
StringBuilder类和String类的区别
String类：内容是不可变的
StringBuilder类：内容是可变的
构造方法：
public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象
示例
public class StringBuilderDemo01 { public static void main(String[] args) { //public StringBuilder()： //创建一个空白可变字符串对象，不含有任何内容 StringBuilder sb = new StringBuilder(); System.out.println("sb:" + sb); System.out.println("sb.length():" + sb.length()); //public StringBuilder(String str)： //根据字符串的内容，来创建可变字符串对象 StringBuilder sb2 = new StringBuilder("hello"); System.out.println("sb2:" + sb2); System.out.println("sb2.length():" + sb2.length()); } }
常用方法
-
-
public String toString() -
public StringBuilder reverse() 返回相反的字符序列
示例一 append方法
public class Demo02StringBuilder { public static void main(String[] args) { //创建对象 StringBuilder builder = new StringBuilder(); //public StringBuilder append(任意类型) StringBuilder builder2 = builder.append("hello"); //对比一下 System.out.println("builder:"+builder); System.out.println("builder2:"+builder2); System.out.println(builder == builder2); //true // 可以添加 任何类型 builder.append("hello"); builder.append("world"); builder.append(true); builder.append(100); // 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。 // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下 //链式编程 builder.append("hello").append("world").append(true).append(100); System.out.println("builder:"+builder); } }
示例二 toString方法
public class Demo16StringBuilder { public static void main(String[] args) { // 链式创建 StringBuilder sb = new StringBuilder("Hello").append("World").append("Java"); // 调用方法 String str = sb.toString(); System.out.println(str); // HelloWorldJava } }
示例三 reverse方法
/* 思路： 1:键盘录入一个字符串，用 Scanner 实现 2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s 3:在方法中用StringBuilder实现字符串的反转，并把结果转成String返回 4:调用方法，用一个变量接收结果 5:输出结果 */ public class StringBuilderTest02 { public static void main(String[] args) { //键盘录入一个字符串，用 Scanner 实现 Scanner sc = new Scanner(System.in); System.out.println("请输入一个字符串："); String line = sc.nextLine(); //调用方法，用一个变量接收结果 String s = myReverse(line); //输出结果 System.out.println("s:" + s); } //定义一个方法，实现字符串反转。返回值类型 String，参数 String s /* 两个明确： 返回值类型：String 参数：String s */ public static String myReverse(String s) { //在方法中用StringBuilder实现字符串的反转，并把结果转成String返回 //String --- StringBuilder --- reverse() --- String // StringBuilder sb = new StringBuilder(s); // sb.reverse(); // String ss = sb.toString(); // return ss; return new StringBuilder(s).reverse().toString(); } }
8，包装类 使用数据作为对象
基本类型包装类的作用
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换
基本类型对应的包装类
Integer类概述 包装一个对象中的原始类型 int 的值
常用方法：
public Integer(int value) 根据 int 值创建 Integer 对象(过时)
public Integer(String s) 根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s) 返回一个保存指定值的 Integer 对象 String
示例
public class IntegerDemo { public static void main(String[] args) { //public Integer(int value)： //根据 int 值创建 Integer 对象(过时) Integer i1 = new Integer(100); System.out.println(i1); //public Integer(String s) //根据 String 值创建 Integer 对象(过时) Integer i2 = new Integer("100"); // Integer i2 = new Integer("abc"); //NumberFormatException System.out.println(i2); System.out.println("--------"); //public static Integer valueOf(int i)： //返回表示指定的 int 值的 Integer 实例 Integer i3 = Integer.valueOf(100); System.out.println(i3); //public static Integer valueOf(String s)： //返回一个保存指定值的Integer对象 String Integer i4 = Integer.valueOf("100"); System.out.println(i4); } }
int和String类型的相互转换
int转String
转换方式
方式一：直接在数字后加一个空字符串
方式二：通过String类静态方法valueOf()
示例代码
public class IntegerDemo { public static void main(String[] args) { //int --- String int number = 100; //方式1 String s1 = number + ""; System.out.println(s1); //方式2 //public static String valueOf(int i) String s2 = String.valueOf(number); System.out.println(s2); System.out.println("--------"); } }
String转换为int
转换方式
方式一：先将字符串数字转成Integer，再调用valueOf()方法
方式二：通过Integer静态方法parseInt()进行转换
示例代码
public class IntegerDemo { public static void main(String[] args) { //String --- int String s = "100"; //方式1：String --- Integer --- int Integer i = Integer.valueOf(s); //public int intValue() int x = i.intValue(); System.out.println(x); //方式2 //public static int parseInt(String s) int y = Integer.parseInt(s); System.out.println(y); } }
-
public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。 -
public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。 -
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。 -
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。 -
public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。 -
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。 -
public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。
代码使用（仅以Integer类的静态方法parseXxx为例）如：
public class Demo18WrapperParse { public static void main(String[] args) { int num = Integer.parseInt("100"); } }
自动拆箱和自动装箱
从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成
自动装箱
把基本数据类型转换为对应的包装类类型
自动拆箱
把包装类类型转换为对应的基本数据类型
示例代码
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4); i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; //加法运算完成后，再次装箱，把基本数值转成对象。
京公网安备 11010502036488号