排序：此处讲解的是冒泡排序选择排序：
冒泡排序：两两比较，大的数放后边，小的数字放前边，第一次比较完毕之后，最大值出现在最大索引处，再一次两两比较，直到按从小到大的顺序排列为止。冒泡排序的次数最多（ 数组元素个数-1）次。
程序如下：
public class MyTest {
public static void main(String[] args) {
// 数组之冒泡排序：两两比较
int[] arr = { 20, 5, 90, 100, 60, 45 };
// 对数组元素进行一个排序
for (int i = 0; i < arr.length - 1; i++) {
//-i 可以优化比较次数
for (int j = 0; j < arr.length - 1-i; j++) {
if (arr[j] > arr[j + 1]) {
// 值交换
int t;
t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
这里Arrays是数组工具类，重写toString方法可自动遍历数组元素，即Arrays.toString(arr);
选择排序：用一个数字和其他数字相比较，遇到较小的数字互换位置，第一次比较完毕之后出现最小值，在0索引的位置。
程序如下：
public class MyTest2 {
public static void main(String[] args) {
// 选择排序：拿1个元素跟剩余的元素挨个去比较
int[] arr = { 20, 5, 90, 100, 60, 45 };
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
// 值交换
int t;
t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
包装类：
jdk1.5以后的版本有新特性：就是自动拆装箱功能
为方便操作，Java给出基本数据类型与之对应的包装类型：
int---------------------------------------------->Integer
byte---------------------------------------------->Byte
long---------------------------------------------->Long
short---------------------------------------------->Short
char---------------------------------------------->Character
float---------------------------------------------->Float
double---------------------------------------------->Double
boolean---------------------------------------------->Boolean
自动装箱：将基本数据类型装箱成引用类型
int类型------->Integerle类型：
int num=100;
Integer integer=new Integer(num); 此时输出的i就是一个引用类型，而并非是基本数据类型````````````````````````````````1式
自动拆箱：将引用类型拆箱成基本的数字类型
Integer类型----------->int类型
int value=integer.intValue(); 此时的integer 来自于1式
int类型--------------->String类型
int num2=100;
String str= String.valueOf(num2); 利用String类的valueOf方法，将int类型的数据转换成String类型
String类型------------>int类型
方式一： 思路：String----------->Integer---------->int
String str2=“200”； 注：此处的字符串里边只能是数字，不然一个字符并不能转换成int类型的数据
Integer integer=new Integer(str2);
int value2=integer.intValue();
方式二：
int value3=Integer.parseInt("230");
static int MAX_VALUE;表示int 类型的最大值，其值为2^31-1；
static int MIN_VALUE:表示int类型的最小值，其值为-2^31;
Integer的静态方法：
int maxValue = Integer.MAX_VALUE;
int minValue = Integer.MIN_VALUE;
构造方法：
public Integer(int value)：将int类型转换成Integer类型
public Integer(String s)：将String类型转换成Integer类型
int num = 100;
Integer integer = new Integer(num);
String string = "50";
Integer integer2 = new Integer(string);
注意事项：
Integer integer=new Integer（127）；
Integer integer2=new Integer（127）；
System.out.println(integer==integer2); false: new对象之后地址值是不相等的
System.out.println(integer.equals(integer2)) true :Integer重写了toString方法之后，比较的是具体的值是否相等
Integer integer3=127；
Integer integer4=127；
System.out.println(integer3==integer4) ; //true, 因为Integer在常量池中开辟了一个空间，将变量integer3的值127放在方法区中，当integer4赋值为127 的时候，会现在方法区中找，看有没有127这个值，如果有直接指向，所以，integer3和integer4实际指向的是一个地址
Integer integer5=129；
Integer integer6=129；
System.out.println(integer5==integer6); false:是因为方法区中存在字节常量池，范围在-128~127之间，当给定的值超过127之后，就会重新在堆内存中new一个空间，这时的地址值就不相等了。
进制之间的转换：
static String toBinaryString(int i)
以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
//static String toHexString(int i)
以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
//static String toOctalString(int i)
以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
String binaryString = Integer.toBinaryString(100);
String octalString = Integer.toOctalString(100);
String hexString = Integer.toHexString(100);
Math类：
Random()
创建一个新的随机数生成器。
Random(long seed)
使用单个 long 种子创建一个新的随机数生成器。
public Random()没有给定种子,使用的是默认的(当前系统的毫秒值)
如果传了种子，那么生成的随机数每次都是固定的
如果不传，每次都是不一样的随机数
Random random = new Random();
boolean nextBoolean() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。
double nextDouble() 返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。
//生成随机数据 int nextInt()
int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
正则表达式：
正则表达式：是一个独立的技术，很多语言都支持他
正确规则的表达式，用来校验数据是否满足我们自己定义的规则
定义一个正则表达式
String regx="[abc]";//允许出现a,b,c中的任意一个
regx="[123ABCabc]";//允许出现1，2，3中任意一个
regx="[^123]";//除了123其他都可以
regx="[0-9]";
regx="[a-z]";
regx="[A-Z]";
regx="[0-9a-zA-Z]";
regx=".";//匹配任意单个字符
regx="\\.";//我想让.代表这个.本身 需要对点进行转意
regx="\\d";//表示[0-9]
regx="\\w";//表示 [a-z_A-Z]
regx="a?b?";//一次或一次也没有 ""空串就代表0次
regx="a*";//零次或多次 大于等于1次 都算多次
regx="a+";//至少一次，或多次
regx="\\w+";
regx="[0-9]{5}";//正好出现几次
regx="[a-z]{5,}";//至少5次
regx="[a-zA-Z0-9]{6,18}";//表示6到18
匹配这个正则表达式：
rege="[a~z]{6,16}";
boolean b= “aaabbb”.matches(regx);
在这里写一个校验邮箱的正则表达式：
String regx="[a-zA-Z0-9]{6,16}@[a-z0-9]{2,16}\\.(com|cn|net)"
boolean b= "ankouchen@126.com".matches(regx);\
System.out.println(b);
根据正则切割字符串的方法：split（）
String str="我--爱--高--园--园";
String[ ] string=str.split("--"); //表示切割“--”字符
System.out.println(Arrays.toString(string));
String str2="我absdh12i爱ndoie24hj你";
String string2=str2.split("\\w+");//表示把数字和字母切割掉
System.out.println(Arrays.toString(string2));
匹配器和模式器：
Pattern和Matcher的概述
Pattern 模式器 用来封装正则表达式
Matcher 匹配器 用来匹配正则表达式
把一个正则表达式封装进模式器里面
Pattern p = Pattern.compile("a*b");
通过模式器，获取匹配器，并传入需要匹配的字符串
Matcher m = p.matcher("aaaaab");
调用匹配器中的方法，进行匹配
boolean b = m.matches();
Matcher 匹配器中的两个方法
boolean find() 查找是否有符合正则的字符串
String group() 获取到符合正则的字符串
203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
