1. 利用java提供的方法进行计算
public class MathDemo {
public static void main(String[] args) {
// public static int abs(int a)返回参数的绝对值
System.out.println(Math.abs(-10));// 10
// public static double ceil(double a)返回最小的（最接近负无穷大）double
// 值，该值大于等于参数，并等于某个整数
System.out.println(Math.ceil(12.12));// 13.0
// public static double floor(double a)返回最大的（最接近正无穷大）double
// 值，该值小于等于参数，并等于某个整数
System.out.println(Math.floor(12.12));// 12.0
// public static double pow(double a,double b)返回a的b次方值
System.out.println(Math.pow(2, 3));// 8.0
// public static int round(float a)四舍五入
System.out.println(Math.round(12.5));// 13
// public static double sqrt(double a)开平方根
System.out.println(Math.sqrt(9));// 3.0
}
}2.二分查找法
import java.util.Arrays;
/*
* Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法
* 排序方法可以使用Comparator接口可以控制升序和降序，这个我们在集合章节讲解
* 二分查找方法默认值针对升序数组有效，如何针对降序数组有效，这个我们在集合章节讲解
*
* public static String toString(int[] a)返回指定数组内容的字符串表示形式
public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序
public static int binarySearch(int[] a,int key)使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
*/
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = { 10, 0, -19, 22, 100, 33 };
// public static String toString(int[] a)返回指定数组内容的字符串表示形式
System.out.println(Arrays.toString(arr));// [10, 0, -19, 22, 100, 33]
// public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序
//Arrays.sort(arr);
ArrayUtils.selectSort(arr, false);
System.out.println(Arrays.toString(arr));// [-19, 0, 10, 22, 33, 100]
// public static int binarySearch(int[] a,int key)使用二分搜索法来搜索指定的 int
// 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[])
// 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
int index = Arrays.binarySearch(arr, 33);
if (index < 0) {
System.out.println("你要查找的元素不在该数组中");
} else {
System.out.println("索引位置：" + index);
}
}
}
3.操作数组的各种方法
import java.util.Arrays;
/*
* Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法
* 排序方法可以使用Comparator接口可以控制升序和降序，这个我们在集合章节讲解
* 二分查找方法默认值针对升序数组有效，如何针对降序数组有效，这个我们在集合章节讲解
*
* public static String toString(int[] a)返回指定数组内容的字符串表示形式
public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序
public static int binarySearch(int[] a,int key)使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
*/
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = { 10, 0, -19, 22, 100, 33 };
// public static String toString(int[] a)返回指定数组内容的字符串表示形式
System.out.println(Arrays.toString(arr));// [10, 0, -19, 22, 100, 33]
// public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序
//Arrays.sort(arr);
ArrayUtils.selectSort(arr, false);
System.out.println(Arrays.toString(arr));// [-19, 0, 10, 22, 33, 100]
// public static int binarySearch(int[] a,int key)使用二分搜索法来搜索指定的 int
// 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[])
// 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则
4.数组的用法
import java.util.Arrays;
import java.util.Scanner;
public class ArraySearch {
public static void main(String[] args) {
// 基本查找 数组元素无序
Scanner sc = new Scanner(System.in);
int[] arr = { 2, 4, 11, 0, -4, 333, 90 };
//数组排序
ArrayUtils.selectSort(arr, false);
System.out.println(Arrays.toString(arr));
System.out.println("请输入要查找的元素值：");
int key = sc.nextInt();
// int index = normalSearch(arr, key);
int index = ArrayUtils.binarySearch(arr, key);
// 根据index的值判断key是否在数组中
if (-1 == index) {
System.out.println("你要查找的元素不在该数组中");
} else {
System.out.println("你要查找的元素在该数组中索引位置：" + index);
}
}
/**
* 使用二分查找指定元素在数组中的位置，如果数组中有多个重复的值，不保证查找到的位置是该元素第一次出现的索引位置
*
* @param arr
* 有序的数组
* @param key
* 要查找的元素
* @return 返回的索引位置
*/
private static int binarySearch(int[] arr, int key) {
// 1.声明开始索引，结束索引
int start = 0, end = arr.length - 1;
// 2.判断start是否小于等于end，如果不满足就结束循环并返回-1；如果满足就计算出中间索引对应的值
while (start <= end) {
int middle = (start + end) / 2;
// 如果满足就计算出中间索引对应的值
int value = arr[middle];
// 3.判断要查找的值key和中间索引对应的值value之间的关系
if (key == value) {// key等于value：
// 直接返回middle，这个middle就是要查找的索引位置
return middle;
} else if (key > value) {// key大于value：
if (arr[0] < arr[arr.length - 1]) {
// 升序：start = middle+1；
start = middle + 1;
} else {
// 降序：end = middle-1；
end = middle - 1;
}
} else {// key小于value：
if (arr[0] < arr[arr.length - 1]) {
// 升序：end = middle-1；
end = middle - 1;
} else {
// 降序：start = middle+1；
start = middle + 1;
}
}
// 4.再返回第2步
}
// 如果不满足就结束循环并返回-1
return -1;
}
/**
* 查找指定元素在该数组中的第一次出现的索引位置
*
* @param arr
* 要被查找的数组
* @param key
* 要查找的元素值
* @return 返回的索引位置
*/
private static int normalSearch(int[] arr, int key) {
// 定义一个位置变量
int index = -1;
// 开始查找key第一次在数组中出现的索引位置
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
index = i;
break;// 如果不加break就是最后一次出现的索引位置
}
}
return index;
}
}
5.冒泡排序
import java.util.Arrays;
public class ArraySort {
public static void main(String[] args) {
int[] arr = { 2, 4, 11, 0, -4, 333, 90 };
System.out.println(Arrays.toString(arr));// [2, 4, 11, 0, -4, 333, 90]
// 冒泡排序：相邻元素两两比较，大的往后放，第一次遍历比较完毕，最大值出现在了最大索引处
// bubbleSort(arr,false);
// 选择排序：从0索引开始，依次和后面元素比较，大的往前放，第一次遍历比较完毕，最大值出现在了最小索引处
selectSort(arr,false);
System.out.println(Arrays.toString(arr));
}
/**
* 使用选择排序对数组进行排序
*
* @param arr
* 要排序的数组
* @param isAsc
* 值为true表示升序，反之表示降序
*/
private static void selectSort(int[] arr, boolean isAsc) {
// 最外层for循环控制的是索引对应的元素值，从索引0开始
for (int i = 0; i < arr.length - 1; i++) {
// 最里层for循环控制的是剩余的索引对应的元素值
for (int j = i + 1; j < arr.length; j++) {
if (isAsc) {
// 升序序：拿前面的元素值和后面的元素值进行比较，小的元素值往前放
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
} else {
// 降序：拿前面的元素值和后面的元素值进行比较，大的元素值往前放
if (arr[i] < arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
}
/**
* 使用冒泡排序对数组进行排序
*
* @param arr
* 要排序的数组
* @param isAsc
* 值为true表示升序，反之表示降序
*/
private static void bubbleSort(int[] arr, boolean isAsc) {
// 最外层控制的是遍历的次数：数组长度-1
for (int i = 1; i < arr.length; i++) {
// 最里层控制的是每一次遍历比较的次数：数组长度-当前遍历的次数
for (int j = 0; j < arr.length - i; j++) {
if (isAsc) {
// 升序：两两之间比较元素的值，大的往后放
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
} else {
// 降序：两两之间比较元素的值，小的往后放
if (arr[j] < arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
}6.数组工具类
/**
* 数组工具类，包含了数组排序和查找的方法
*
* @author xzy
*
*/
public class ArrayUtils {
/**
* 使用二分查找指定元素在数组中的位置，如果数组中有多个重复的值，不保证查找到的位置是该元素第一次出现的索引位置
*
* @param arr
* 有序的数组
* @param key
* 要查找的元素
* @return 返回的索引位置
*/
public static int binarySearch(int[] arr, int key) {
// 1.声明开始索引，结束索引
int start = 0, end = arr.length - 1;
// 2.判断start是否小于等于end，如果不满足就结束循环并返回-1；如果满足就计算出中间索引对应的值
while (start <= end) {
int middle = (start + end) / 2;
// 如果满足就计算出中间索引对应的值
int value = arr[middle];
// 3.判断要查找的值key和中间索引对应的值value之间的关系
if (key == value) {// key等于value：
// 直接返回middle，这个middle就是要查找的索引位置
return middle;
} else if (key > value) {// key大于value：
if (arr[0] < arr[arr.length - 1]) {
// 升序：start = middle+1；
start = middle + 1;
} else {
// 降序：end = middle-1；
end = middle - 1;
}
} else {// key小于value：
if (arr[0] < arr[arr.length - 1]) {
// 升序：end = middle-1；
end = middle - 1;
} else {
// 降序：start = middle+1；
start = middle + 1;
}
}
// 4.再返回第2步
}
// 如果不满足就结束循环并返回-1
return -1;
}
/**
* 查找指定元素在该数组中的第一次出现的索引位置
*
* @param arr
* 要被查找的数组
* @param key
* 要查找的元素值
* @return 返回的索引位置
*/
public static int normalSearch(int[] arr, int key) {
// 定义一个位置变量
int index = -1;
// 开始查找key第一次在数组中出现的索引位置
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
index = i;
break;// 如果不加break就是最后一次出现的索引位置
}
}
return index;
}
/**
* 使用选择排序对数组进行排序
*
* @param arr
* 要排序的数组
* @param isAsc
* 值为true表示升序，反之表示降序
*/
public static void selectSort(int[] arr, boolean isAsc) {
// 最外层for循环控制的是索引对应的元素值，从索引0开始
for (int i = 0; i < arr.length - 1; i++) {
// 最里层for循环控制的是剩余的索引对应的元素值
for (int j = i + 1; j < arr.length; j++) {
if (isAsc) {
// 升序序：拿前面的元素值和后面的元素值进行比较，小的元素值往前放
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
} else {
// 降序：拿前面的元素值和后面的元素值进行比较，大的元素值往前放
if (arr[i] < arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
}
/**
* 使用冒泡排序对数组进行排序
*
* @param arr
* 要排序的数组
* @param isAsc
* 值为true表示升序，反之表示降序
*/
public static void bubbleSort(int[] arr, boolean isAsc) {
// 最外层控制的是遍历的次数：数组长度-1
for (int i = 1; i < arr.length; i++) {
// 最里层控制的是每一次遍历比较的次数：数组长度-当前遍历的次数
for (int j = 0; j < arr.length - i; j++) {
if (isAsc) {
// 升序：两两之间比较元素的值，大的往后放
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
} else {
// 降序：两两之间比较元素的值，小的往后放
if (arr[j] < arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
}
7，das
/*
* Character类：在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
*/
public class CharacterDemo {
public static void main(String[] args) {
// public static boolean isUpperCase(char ch)判断参数字符是否是大写
// public static boolean isLowerCase(char ch)判断参数字符是否是小写
// public static boolean isDigit(char ch)判断参数字符是否是数字字符
// public static char toUpperCase(char ch)将参数字符转换成大写
// public static char toLowerCase(char ch)将参数字符转换成小写
}
}
8.日期的使用
import java.util.Date;
/*
* 把时间封装成了Date类
*
* 类 Date 表示特定的瞬间，精确到毫秒
*/
public class DateDmo {
public static void main(String[] args) {
// public Date()分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date date = new Date();//date表示代码执行到一行的当前时间，单位是毫秒
System.out.println(date);
//从Date对象中取出毫秒值
//public long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数
System.out.println(date.getTime());
//可以将毫秒值封装成Date对象
//public Date(long date)分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数
date = new Date(System.currentTimeMillis()+3*60*1000);//3分钟之后的时间
System.out.println(date);
//更新date表示的时间
//public void setTime(long time)设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点
date.setTime(System.currentTimeMillis()+6*60*1000);//6分钟之后的时间
System.out.println(date);
}
}
9.包装类
/*
* 包装类概述：将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
* 基本数据类型对应的包装类：
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
*
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
*/
public class IntegerDemo {
public static void main(String[] args) {
//获取每种数据类型表示的范围
System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println(Integer.MIN_VALUE);//-2147483648
System.out.println(Float.MAX_VALUE);//3.4028235E38
System.out.println(Float.MIN_VALUE);//1.4E-45
//...
//比较特殊：Boolean没有最大值和最小值
//字符串和基本数据类型之间做运算
String s = "123";
int i = Integer.parseInt(s);
System.out.println(i);//123
System.out.println(i+"");//123
System.out.println(String.valueOf(i));
long l = Long.parseLong(s);
System.out.println(l);//123
//...
//比较特殊；Character没有讲字符串转换成字符的方法，可以使用String的charAt方法转换
Integer a = 123;//JDK1.5新特性：自动装箱
int b = a;//JDK1.5新特性：自动拆箱
Boolean b2 = false;//JDK1.5新特性：自动装箱
boolean b3 = b2;//JDK1.5新特性：自动拆箱
//...
}
}
10.使用API进行进制转换
public class IntegerDemo2 {
public static void main(String[] args) {
// 常用的基本进制转换
int i = 100;
// public static String toBinaryString(int i)将整数转换成二进制的字符串表示形式
System.out.println(Integer.toBinaryString(i));//1100100
// public static String toOctalString(int i)将整数转换成八进制的字符串表示形式
System.out.println(Integer.toOctalString(i));//144
// public static String toHexString(int i)将整数转换成十六进制的字符串表示形式
System.out.println(Integer.toHexString(i));//64
// 十进制到其他进制
// public static String toString(int i,int radix)将整数i转换成radix进制，radix是几就转换成几进制
System.out.println(Integer.toString(i, 2));//1100100
System.out.println(Integer.toString(i, 3));//10201
System.out.println(Integer.toString(i, 4));//1210
System.out.println(Integer.toString(i, 8));//144
System.out.println(Integer.toString(i, 16));//64
// 其他进制到十进制
// public static int parseInt(String s,int radix)将其他进制的字符串s转换成十进制，s本身是几进制，radix就填几
System.out.println(Integer.parseInt("1100100",2));//100
System.out.println(Integer.parseInt("10201",3));//100
System.out.println(Integer.parseInt("144",8));//100
}
}
11.随机数的使用
import java.util.Random;
/*
* Random类：此类的实例用于生成伪随机数
*/
public class RandomDemo {
public static void main(String[] args) {
// Random() 创建一个新的随机数生成器。
Random r = new Random();
Random r2 = new Random();
//int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值
System.out.println(r.nextInt());
System.out.println(r2.nextInt());
// Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。
r = new Random(10);
r2 = new Random(10);
System.out.println(r.nextInt());//-1157793070
System.out.println(r2.nextInt());//-1157793070
}
}
12.获取一个指定范围的随机数
import java.util.Random;
public class RandomDemo2 {
public static void main(String[] args) {
// 获取随机数：1-100之间
Random r = new Random();
int value = 1 + r.nextInt(100);
// 获取随机数：start到end之间
int start = 3;
int end = 8;
for(int i=0; i<20; i++){
value = getRandomNumber(start, end);
System.out.println(value);
}
}
/**
* 获取指定区间的值
*
* @param start
* 开始值(包含)
* @param end
* 结束值(包含)
* @return 区间中的随机值
*/
private static int getRandomNumber(int start, int end) {
Random r = new Random();
return start + r.nextInt(end - start + 1);
}
private static void test() {
Random r = new Random();
// int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的
// int 值。
for (int i = 0; i < 20; i++) {
System.out.println(r.nextInt(5));// 值的范围：0-4
}
}
}
13.设置指定格式的日期
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
*/
public class SimpleDateFormatDemo {
public static void main(String[] args) throws Exception {
//注意：格式化和解析使用的必须是统一(pattern)模板
//格式化（日期 -> 文本）
format();
//解析（文本 -> 日期）
parse();
}
//解析（文本 -> 日期）
private static void parse() throws Exception {
String txt = "18-4-12 下午5:25";
//用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
SimpleDateFormat sdf = new SimpleDateFormat();//使用操作系统环境的默认模板
//public Date parse(String source)从给定字符串的开始解析文本，以生成一个日期
Date date = sdf.parse(txt);
System.out.println(date.getTime());//1523525100000
txt = "2018/04/12 17:25:51";
//public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//自定义日期模板
date = sdf.parse(txt);
System.out.println(date.getTime());//1523525151000
}
//格式化（日期 -> 文本）
private static void format() {
Date date = new Date();//表示当前的时间
//创建以格式化日期类对象
//用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
SimpleDateFormat sdf = new SimpleDateFormat();//使用操作系统环境的默认模板
//public final String format(Date date)将一个 Date 格式化为日期/时间字符串
String txt = sdf.format(date);
System.out.println(txt);// 18-4-12 下午5:25
//public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//自定义日期模板
txt = sdf.format(date);
System.out.println(txt);// 2018/04/12 17:25:51
}
}
14.模拟登陆验证
import java.util.Scanner;
/*
* 模拟用户登录操作，一共有三次登录机会，如果登录失败需要提供还剩几次机会，机会用完，提示今日登录次数已用完
*/
public class StringTest {
public static void main(String[] args) {
String username = "小王";
String password = "xiaowang123";
Scanner sc = new Scanner(System.in);
// 一共有三次登录机会
for (int i = 0; i < 3; i++) {
System.out.println("请输入用户名：");
String user = sc.nextLine();
System.out.println("请输入密码：");
String pwd = sc.nextLine();
if (user.equals(username) && pwd.equals(password)) {
System.out.println("登录成功，3秒钟之后跳转到首页...");
break;
} else {
//判断还有几次机会
if(i==2){
System.out.println("今日次数已用完，请明天再试.");
}else{
//2-i=2 1
System.out.println("登录失败，你还剩"+(2-i)+"次机会");
}
}
}
}
}15.统计一个数组中字符出现的次数
/*
* String s = “abcJJLKjlkJLKJ89HKJhhHJ789HJ889H”;
1.遍历获取字符串中的每一个字符
2.统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
*/
public class StringTest2 {
public static void main(String[] args) {
String s = "abcJJLKjlkJLKJ89HKJhhHJ789HJ889H";
// 2.统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
int upperCount = 0;
int lowerCount = 0;
int numberCount = 0;
// 1.遍历获取字符串中的每一个字符
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
System.out.print(ch + ",");
if (ch >= 'A' && ch <= 'Z') {
upperCount++;
} else if (ch >= 'a' && ch <= 'z') {
lowerCount++;
} else if (ch >= '0' && ch <= '9') {
numberCount++;
}
}
System.out.println();
System.out.println("大写字符："+upperCount);//大写字符：16
System.out.println("小写字符："+lowerCount);//小写字符：8
System.out.println("数字字符："+numberCount);//数字字符：8
}
}16.特定英文字符的大小写转换
public class StringTest3 {
public static void main(String[] args) {
//把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
String s = "aBcdEfG";
// 把第一个字符截取出来
String start = s.substring(0, 1).toUpperCase();
// 把剩余的字符串截取出来
String end = s.substring(1).toLowerCase();
System.out.println(start + end);
//将字符串”axhhauububbuaa”中的字母”a,b”删除然后输出
s = "axhhauububbuaa";
String result = s.replace("a", "").replace("b", "");
System.out.println(result);
}
}
17.字符串的反转
import java.util.Scanner;
//字符串反转，例如键盘录入abc，输出cba（不能使用StringBuilder的方法，不能逆序输出）
public class StringTest4 {
public static void main(String[] args) {
//1.键盘录入数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串：");
String s = sc.nextLine();
//2.将字符串转换成字符数组
char[] charArray = s.toCharArray();
//3.将数组中的元素反转
for(int i=0,j=charArray.length-1; i<j; i++,j--){
char temp = charArray[i];
charArray[i] = charArray[j];
charArray[j] = temp;
}
//4.将字符数组转换成字符串
System.out.println(new String(charArray));
}
}
18 字符串的截取
//截取字符串”中中国你最美，中国你是我的祖国中”中的“中国”然后输出
public class StringTest5 {
public static void main(String[] args) {
String s = "中中国你最美，中国你是我的祖国中中中国";
// 获取当前的字符和下一个字符，如果合起来是“中国”那么就直接输出
for (int i = 0; i < s.length() - 1; i++) {
if (s.charAt(i) == '中' && s.charAt(i + 1) == '国') {
System.out.println("中国");
}
}
}
}
19 垃圾回收器和java虚拟机和数组的复制
import java.util.Arrays;
/*
* System 类包含一些有用的类字段和方法。它不能被实例化
*/
public class SystemDemo {
public static void main(String[] args) {
// public static void gc()运行垃圾回收器。 调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间
// public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止
//System.exit(0);//终止当前正在运行的 Java 虚拟机
//System.out.println("哈哈哈");
// public static long currentTimeMillis()当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）
System.out.println(System.currentTimeMillis());
for(int i=0;i<1000000;i++);
System.out.println(System.currentTimeMillis());
// public static void arraycopy(Object src,int srcPos,Object dest,int
// destPos,int length)从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
int[] src = {1,2,3,4,5,6};//src - 源数组。
int srcPos = 2;//srcPos - 源数组中的起始位置。
int[] dest = new int[5];//dest - 目标数组。
int destPos = 1;//destPos - 目标数据中的起始位置。
int length = 3;//length - 要复制的数组元素的数量。
System.out.println(Arrays.toString(dest));//[0, 0, 0, 0, 0]
System.arraycopy(src, srcPos, dest, destPos, length);
System.out.println(Arrays.toString(dest));//[0, 3, 4, 5, 0]
}
}
20包装类比喻图解
21. 二分查找法思路图解
22.冒泡排序原理图解
23选择排序思路图解
24求区间的随机值图解
