JavaSE_day10：排序，包装类，Math类，正则表达式：

51 阅读 0 评论 34 点赞

我是靠谱客的博主风趣黄蜂，最近开发中收集的这篇文章主要介绍JavaSE_day10：排序，包装类，Math类，正则表达式：，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

排序：此处讲解的是冒泡排序选择排序：

冒泡排序：两两比较，大的数放后边，小的数字放前边，第一次比较完毕之后，最大值出现在最大索引处，再一次两两比较，直到按从小到大的顺序排列为止。冒泡排序的次数最多（数组元素个数-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() 获取到符合正则的字符串