zoukankan html css js c++ java

包装类（Integer)；自动拆装箱；正则表达式；对象型数组；集合；Collection；遍历（Java day13)

一，包装类

概述：就是对基本数据类型数据进行包装的类【基本数据类型对应的引用数据类型】
基本数据类型只是确定数据在空间中的大小标准，只能表示数值，想要对数据进行相关的操作做不了。使用类来对操作数据的行为进行描述。那么对应类就是包装类。

byte ------------------------ Byte
short ------------------------- Short
int --------------------------Integer【特殊常用】
long--------------------------Long
float --------------------------Float
double ----------------------Double
char ------------------------ Character【特殊常用】
boolean--------------------Boolean

包装类的一些功能原理上是相似的，只需要学习一种典型类，其他的类就可以借鉴学习了
包装类对象赋值的时候可以随便赋值？不可以，赋值的时候数据严格的遵守基本数据类型对应的数据范围进行赋值
Byte 的对象赋值的时候只能赋值 -128 到 127 之间的数据
Integer
概述：它是int对应的引用数据类型【int的包装类】
引用数据类型的使用：

类名调用资源
对象调用资源

构造方法

 Integer（int num）：把一个 int类型 的数据变成一个 Integer 的对象
Integer（String s）：把一个 字符串类型 的数字变成一个 Integer 的对象

字符串类型的数字：比如 “123”
成员方法：【使用对象来调用的方法】

xxxValue(): 把 integer对象转变为其他基本数据类型。
要转变成那个基本数据类型，Xxx 就是对应的基本数据类型
调用对应的 xxxValue（）方法的时候确保 Integer 中的数据要在对应的基本数
据类型的范围内，超范围不报错，得到的不是我们想要的结果
 intValue（）：把 Integer 的对象转变成对应的 int类型 的数据

静态方法：
将int类型转为String

Integer.parseInt(String s ): 把一个字符串类型的数字转变int数字
Integer.toBinaryString（int i）：把一个数按照二进制方式转变对应的字符串值
Integer.toOctalString（int i）：把一个数按照八进制方式转变对应的字符串值
Integer.toHexString（int i ）：把一个数按照十六进制方式转变对应的字符串值
Integer.toString（int i， int radix）：把一个数按照指定的进制方式转变对应的字符串值

解释：radix参数写几就按照几进制来转换对应的字符串值，不写默认是10进制

6. String.valueOf（String s）：把一个字符串的数字转变成 Integer 对象

代码示例

public class Demo02 {
public static void main(String[] args) {
    //静态方法
    int i = Integer.parseInt("521"); //字符串到基本数据类型的途径
    System.out.println(i);  //int 类型的521
    System.out.println(i*23); //转换之后可以进行运算
    
    String binString = Integer.toBinaryString(8); //对应的二进制的数是1000，
    System.out.println(binString); //字符串1000
    
    String octalString = Integer.toOctalString(8);
    System.out.println(octalString); //字符串10
    
    String heString =Integer.toHexString(17);
    System.out.println(heString); //11
    
    String string =Integer.toString(8);
    System.out.println(string); //8
    
    String string1 =Integer.toString(8, 2);
    System.out.println(string1); //1000
    
    Integer integer = Integer.valueOf(30); //是int和string到integer的途径
    Integer integer2 = Integer.valueOf("50");
    System.out.println(integer); //基本数据类型转变为引用数据类型
    System.out.println(integer2); //字符串类型转变为引用数据类型
    
    //直接拆装箱
    Integer a = 12; //自动装箱 引用数据类型到基本数据类型
    int b =integer; //自动拆箱  基本数据类型到引用数据类型
}
}

自动拆装箱

装箱：把基本数据类型的数据变成引用数据类型【包装类】的过程叫做装箱
拆箱：把包装类类型的对象变成对应基本数据类型过程叫做拆箱
自动装箱：在Java中把基本数据类型的数据直接赋值给包装类类型变量
自动拆箱：在Java中把包装类类型的数据直接赋值给基本数据类型变量
jdk1.5开始自动给我们维护了自动拆箱装箱的过程，我开发的时候不需要去关注自动拆装箱的问题。【XXXValue（）和构造方法基本处于不使用状态】

常量

MAX_VALUE:int 类型的最大值
MIN_VALUE:int 类型的最小值
SIZE：int类型的内存中的位数 int 是32倍的bit
TYPE：int类型在方法区中的字节码文件对象：int.class

代码示例

public class Demo03 {
public static void main(String[] args) {
    //属性都可以直接打印
     
    system.out.println(Integer.BYTE);  //4   一个int 是4个byte
    System.out.println(Integer.MAX_VALUE);//2147483647    int 类型的最大值
    System.out.println(Integer.MIN_VALUE); //-2147483647  int 类型的最小值

    System.out.println(Integer.SIZE); //32 
    System.out.println(Integer.TYPE); //int  
}
 }

相互转换：

 int 到 Integer： Integer构造方法 valueOf(int num)
int 到 String：toString（int num，int j）、字符串拼接【3+""】
 Integer 到 int：intValue（）
Integer 到 String ：先变成int 在变成String
String 到 int： parseInt（String s）【最常用的】

 6. String 到 Integer ：构造方法、valueOf（String s）

public class Demo02 {
public static void main(String[] args) {
    //类型转换
    
    //int >>> integer
    //1.构造方法
    Integer i=new Integer(10);
    System.out.println(i); //10
    //2.valueOf(int)方法
    Integer ii = Integer.valueOf(21);
    System.out.println(ii);  //21
    
    //string >>> integer
    //1.构造方法
    Integer ss= new Integer("122");
    System.out.println(ss+1);//123
    //2.valueOf(string)方法
    Integer s=Integer.valueOf("123");
    System.out.println(s+1);//124
    
    //integer >>> int
    //intValue()方法
    int a= s.intValue();
    System.out.println(a+2);//123+2=125
    
    //integer >>> string
    //1.toString()方法
    String s1=s.toString();
    System.out.println(s1+123);//123123
    //2.String.valueOf(Object)
    String s2=String.valueOf(s1);
    System.out.println(s2+111); //123111
    //3.+方法
    
    //int >>> string
    //1.Integer.toString(int)方法
    String ss1=Integer.toString(12);
    System.out.println(ss1+12);//1212
    //2.String.valueOf(int)方法
   String ss2=String.valueOf(12);
   System.out.println(ss2+12);//1212
    //3.+方法
   
    //string >>> int
   //1.Integer.parseInt(String)方法
    int b = Integer.parseInt("111");
    System.out.println(b+2);//113
}
}

二，正则表达式

概述：一个有特殊含义的字符串。
作用：他可以给创建字符串对象提供标准和规范。
好处：可以给我们提供验证标准，使开发代码变得简单了比如：用户登录
坏处：验证测试的几率变得低了。
使用：使用字符串的 matches 方法判断该字符串是否符合正则表达式的规范
符合就返回 true 不符合就返回 false
正则表达式的基本内型
特殊字符：

\ 代表
制表符 tab键的内容
新行换行
换行

字符类型：使用 [] 来表示，表示一个字符比如：

[abc] ：表示 a 或 b 或c只出现其中之一
[^abc] : 表示除去abc之外的任意一个其他字符
[a-zA-Z]: 只能出现a到z和A到Z之间的任意一个字符
a、z、 A、Z 只是字符的代表可以更换的

代码示例

public class Demo04 {
public static void main(String[] args) {
    method01();
    method02();
    String regex = "[b-mD-K]"; //在此范围内
    //使用其他的字符串来匹配这个正则   匹配上了 就返回true 否则返回false
    System.out.println("".matches(regex));//false
    System.out.println(" ".matches(regex));//false
    System.out.println("a".matches(regex));//false
    System.out.println("A".matches(regex));//false
    System.out.println("J".matches(regex));//true
    System.out.println("k".matches(regex));//true
    System.out.println("0".matches(regex));//false
    System.out.println(",".matches(regex));//false
    System.out.println("12".matches(regex));//false
    System.out.println("jk".matches(regex));//false
}
private static void method02() {
    String a = "[^amn]"; //非amn
    //使用其它的字符串匹配正则，匹配上了就返回true，否则返回false
    System.out.println("".matches(a)); //false 
    System.out.println(" ".matches(a)); //true
    System.out.println("a".matches(a)); //false 
    System.out.println("an".matches(a)); //false 
    System.out.println("am".matches(a)); //false 
    System.out.println("m".matches(a));  //false 
    System.out.println("n".matches(a)); //false 
    System.out.println(",".matches(a)); //true 
}
private static void method01() {
    String a = "[amn]"; //含amn
    //使用其它的字符串匹配正则，匹配上了就返回true，否则返回false
    System.out.println("".matches(a)); //false ""里面与abc进行匹配,没有内容，无法匹配
    System.out.println(" ".matches(a)); //false 没有内容，无法匹配
    System.out.println("a".matches(a)); //true 里面有a匹配上了
    System.out.println("an".matches(a)); //false 中扩后里面只能是一个字符，这里有两个所以无法匹配
    System.out.println("am".matches(a)); //false 中扩后里面只能是一个字符，这里有两个所以无法匹配
    System.out.println("m".matches(a));  //true 里面有m匹配上了
    System.out.println("n".matches(a)); //true 里面有n匹配上了
    System.out.println(",".matches(a)); //false 无法匹配
}
}

预定义字符

. 任何字符（与行结束符可能匹配也可能不匹配）
d 数字：相当于 [0-9]
D 非数字：相当于[^0-9]
s 空白字符：相当于 [ x0Bf ]
S 非空白字符：相当于[^s]
w 单词字符：相当于[a-zA-Z_0-9]
W 非单词字符：相当于[^w]

代码示例

public class Demo05 {
public static void main(String[] args) {
    method01();
    nethod02();
    method03();
    method04();
    method05();
    String a  ="\W"; //相当于[^w]   非26个大小写字母+0-9
    System.out.println("".matches(a)); //false 没有字符
    System.out.println("11".matches(a)); //false,数量不对
    System.out.println("a".matches(a)); //false
    System.out.println("A".matches(a)); //false
    System.out.println("2".matches(a)); //false
    System.out.println("9".matches(a)); //false
    System.out.println(" ".matches(a)); //true 空白字符
    System.out.println("===================");
}

private static void method05() {
    String a  ="\w"; //相当于[a-zA-Z_0-9] 26个大小写字母+0-9
    System.out.println("".matches(a)); //false 没有字符
    System.out.println("11".matches(a)); //false,数量不对
    System.out.println("a".matches(a)); //true
    System.out.println("A".matches(a)); //true
    System.out.println("2".matches(a)); //true
    System.out.println("9".matches(a)); //true
    System.out.println(" ".matches(a)); //false 空白字符
    System.out.println("===================");
}

private static void method04() {
    String a  ="\S"; //相当于[^s]  非空白字符
    System.out.println("".matches(a)); //false 没有字符
    System.out.println("11".matches(a)); //false,数量不对
    System.out.println("a".matches(a)); //true
    System.out.println("A".matches(a)); //true
    System.out.println("2".matches(a)); //true
    System.out.println("9".matches(a)); //true
    System.out.println(" ".matches(a)); //false 空白字符
    System.out.println("===================");
}

private static void method03() {
    String a  ="\s"; //相当于 [ 	
x0Bf
] 空白字符
    System.out.println("".matches(a)); //false 没有字符
    System.out.println("11".matches(a)); //false ，数量不对
    System.out.println("a".matches(a)); //false
    System.out.println("A".matches(a)); //false
    System.out.println("2".matches(a)); //false 
    System.out.println("9".matches(a)); //false
    System.out.println(" ".matches(a)); //true 空白字符
    System.out.println("===================");
}

private static void nethod02() {
    String a  ="\D"; //相当于[^0-9] 非0-9
    System.out.println("".matches(a)); //false 没有字符
    System.out.println("11".matches(a)); //false 数量不对
    System.out.println("a".matches(a)); //true
    System.out.println("A".matches(a)); //true
    System.out.println("2".matches(a)); //false 
    System.out.println("9".matches(a)); //false
    System.out.println(" ".matches(a)); //true
    System.out.println("===================");
}

private static void method01() {
    String a  ="\d"; //相当于 [0-9] 
    System.out.println("".matches(a)); //false
    System.out.println(" ".matches(a)); //false
    System.out.println("a".matches(a)); //false
    System.out.println(" A".matches(a)); //false
    System.out.println("2".matches(a)); //true
    System.out.println("22".matches(a)); //false因为有两个字符，数量不对
    System.out.println(",".matches(a)); //false
    System.out.println("====================");
}
}

数量词
分为模糊和精确

X：代表修饰的字符
规定：只能修饰一个字符跟在谁的后面修饰谁

模糊的：

X? X，一次或一次也没有【一次或者0次】
X* X，零次或多次【0次或多次】
X+ X，一次或多次【1次或多次】

精确的：使用{}表示精确 n和 m是具体的数字

X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

代码示例

public class Demo06 {
public static void main(String[] args) {
    method01();
    String a = "[abc]{3}m{2,}1{2,5}"; //符号修饰符号前面的字母,a/b/c恰好3次，m至少2次，1至少2次不超过5次
    System.out.println("aaammmmmm11".matches(a)); //true
    System.out.println("abcm1111".matches(a)); //false
    System.out.println("cccmmmmm11111".matches(a));  //true
    System.out.println("bbmmm111".matches(a)); //false
}

private static void method01() {
    String a = "a?mb*kc+"; //符号修饰符号前面的字母
    System.out.println("ambbbbbkcccc".matches(a)); //true
    System.out.println("abkcccccccccc".matches(a)); //false
    System.out.println("ambbkcc".matches(a));  //true
    System.out.println("ambbbbbbbbbkccccccc".matches(a)); //true 字母所在的位置不能变
    System.out.println("===========");
}
}

案例

qq验证
键盘录入一个字符串作为qq号码，验证qq是不是正确的qq号
提示：长度有限制【5到 15位】
内容：必须是数字
分析：QQ号首字母不能是0 后面的随意，但是长度不能小于5不能大于15
正则表达式表示标准的QQ：[1-9][0-9]{4,14}

代码示例


import java.util.Scanner;
public class Demo07 {
public static void main(String[] args) {
    //定义QQ号码的正则表达式
    String a = "[1-9][0-9]{4,14}";
    //键盘录入QQ号码
    Scanner sc = new Scanner(System.in);
    System.out.println(" 请输入一个字符串作为qq号码：");
    String qq =sc.next();
   if (qq.matches(a)) {
        System.out.println("恭喜你登陆成功");    
    }else {
        System.out.println("你输入的qq号码有误，请重新登陆");
    }
}
}

三，对象型数组

数组：存放多个同一引用数据类型的对象的容器
特点：

一旦定义长度不变
定义后只能存放同一数据类型的数据
没定义前可以存存放任何数据类型

概述：存放引用数据类型数据的数组对象型数组
比如：String[]、二维数组
对象型数组有什么缺陷？

只能存放单一数据类型
长度不能变了

比如：

数组中存放的是Person类型的对象，想往里面放Student类的对象放不进去
数组创建出来长度是5，想要6个对象，放不下，只能重新创建新的数组。
数组中实际存放的是对象的地址值。
如果想存放不同的类型的对象在一个容器中数组实现不了，jdk想办法提供了集合出来。

四，集合的概述

集合概述：就是一个专门存放多个引用数据类型对象的容器【只能存放引用数据类型】
说白点：集合就是一个存放引用数据类型对象的容器
特点：

他可以存放多种数据类型对象
集合的长度可变的
支持泛型

集合和数组的对比：【面试】
 数组：

创建后只能存放单一数据类型【所有的数据类型】创建前可以存放任意数据类型
创建后长度不能改变
基本上没有功能【方法】

集合：

属于类和接口体系【本身也是引用数据类型】
集合只能存放引用数据类型，不能存放基本数据类型
集合长度自动维护，所以可变
集合拥有自己的操作方法

集合的体系
概述：集合的内容组成结构
内容：
根据集合位置上存放的数据个数不同分为：

单列集合【Collection】：每个位置存放的是单一数据
双列集合【Map】：每个位置存放的是一对有关系的数据

单列集合根据存放和取出的顺序是否一致分为

 有序集合【List】：存数据和取数据顺序一致的单列集合
1.1 实现类：ArrayList、LinkedList、Vector【基本被淘汰】
无序集合【Set】：存数据和取数据顺序不一致的单列集合
2.1 实现类：HashSet
LinkedHashSet

双列集合【Map】

实现类：HashMap
LinkedHashMap

五，Collection

概述：是单列集合的顶层接口，在定义所有单列集合一些共性功能。要想使用里面的资源必须找他的实现类，接下来学习他的资源使用 ArrayList 这个实现类来调用
常用方法：

 add（E e）： 添加数据e到集合中【增加】
 remove（E e）：删除集合中指定的元素e【删除单一元素】
 clear（）：一次性清空集合【删除全部】
contains（E e）：判断集合中是否包含元素e【查询】
size（）：获取集合当前的长度【获取当时集合的内容的长度】
isEmpty（）：判断集合是否存放数据

代码示例一


import java.util.ArrayList;
import java.util.Collection;

//集合
public class Demo_Collection {
public static void main(String[] args) {
    Collection c =new ArrayList();
    System.out.println(c); //[]
    c.add("花花");
    c.add("花花1");
    c.add("花花2");
    c.add("花花3");
    c.add("花花4");
    c.add("花花5");
    System.out.println(c);  //[花花, 花花1, 花花2, 花花3, 花花4, 花花5]
    
    c.remove("花花"); 
    System.out.println(c); //  [花花1, 花花2, 花花3, 花花4, 花花5] 删除花花
    
   boolean b = c.contains("花花");
    System.out.println(b); //false 没有包含花花，花花被删除了
    
    System.out.println(c.isEmpty()); // false 有元素
    System.out.println(c.size());//5 有5个元素
    
    c.clear();
    System.out.println(c.isEmpty()); // true 清空了没有元素
    System.out.println(c.size()); //0 清空了没有元素
}
}

all方法: 批量操作

addAll(Collection c): 把参数c集合中的全部内容存放到调用集合中
removeAll（Collection c）：把参数集合c中的内容从调用集合中删除
containsAll（Collection c）：判断调用集合中是否包含参数集合c中的内容
retainAll（Collection c）：在调用集合中保留参数集合的内容其他的删除

代码示例二


import java.util.ArrayList;
import java.util.Collection;
public class Demo_Collection02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        System.out.println(c); //[]
        c.add("A");
        c.add("B");
        c.add("C");
        c.add("D");
        c.add("E");
        c.add("F");
        Collection c1 = new ArrayList();
        System.out.println(c1); // []
        c1.addAll(c);
        System.out.println(c1); // [A, B, C, D, E, F]
        
        Collection c2=new ArrayList();
        c2.add("B");
        c2.add("C");
        c2.add("E");
        c1.removeAll(c2);
        System.out.println(c2); // [B, C, E]
        System.out.println(c1); // [A, D, F]
        
        System.out.println(c); // [A, B, C, D, E, F]
        System.out.println(c.containsAll(c1)); // true
        
        c.retainAll(c1);
        System.out.println(c); //保留c1的内容其它的都删除 [A, D, F]
        
    }
    
}



六，遍历

第一种遍历方式：数组法【不常用】
原理：

想办法把集合转变成数组
利用for循环对数组进行遍历
集合转数组：
 Collection 中提供方法 toArray（）：可以把集合转变为数组

代码示例


import java.util.ArrayList;
import java.util.Collection;
public class Demo_Collection03 {
public static void main(String[] args) {
    Collection c =new ArrayList();
    c.add("A");
    c.add("B");
    c.add("C");
    c.add("D");
    c.add("E");
    c.add("F");
    //数组法,
    //首先用toArray将c变成数组,再遍历数组。
    Object[] array= c.toArray();
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);

第二种遍历方式：迭代器遍历
迭代器（Iterator）：他是一个接口，它里面的功能可以对集合进行遍历
Iterator的方法：

hashNext（）：判断下一个位置是否有元素【判断】
next（）：有元素取出该位置的元素【获取元素】
remove（）：删除正在遍历的那个元素

执行原理：

注意： hasNext（） 执行的次数是集合长度+1

next（） 方法执行次数就是集合的长度

remove（）要想起作用先把next（）执行了

步骤：

1、通过集合的方法 iterator（）获取迭代器对象

集合中提供方法 iterator（）可以得到迭代器的对象

2、迭代器调用 hasNext（）判断下个位置是否有值

3、迭代器调用 next（）取对应位置上面的数值结合循环完成。

代码示例


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo_Collection03 {
public static void main(String[] args) {
    Collection c =new ArrayList();
    c.add("A");
    c.add("B");
    c.add("C");
    c.add("D");
    c.add("E");
    c.add("F");
    //数组法,
    //首先用 toArray 将c变成数组,再遍历数组。
    Object[] array= c.toArray();
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
        System.out.println("=============");
        
        //迭代器遍历  [ 以后用的较多]
        //使用集合对象iterator方法得到迭代器
    Iterator n =  c.iterator();
    while(n.hasNext()) {  //判断位置是否有值
         Object next = n.next();  //有值就取出来
         System.out.println(next);
     }
    }
}
}

查看全文

相关阅读:
Servlet访问第一次500，刷新后404的解决办法
 关于eclipse保存代码很慢,提示the user operation is waiting的问题
 编译时，运行时解释
 JDK、JRE、JVM
IDEA使用maven中tomcat插件启动项目乱码问题
 treeGrid树形数据表格的json数据格式说明
 Maven最佳实践：Maven仓库（转）
intelliJ idea debug模式下启动慢的原因
 基于 Annotation 拦截的 Spring AOP 权限验证方法
 化繁为简如何向老婆解释MapReduce？（转载）

原文地址：https://www.cnblogs.com/nastu/p/12451776.html

包装类（Integer)；自动拆装箱；正则表达式；对象型数组；集合；Collection；遍历（Java day13)

一，包装类

Integer

自动拆装箱

常量

相互转换：

二，正则表达式

正则表达式的基本内型

三，对象型数组

四，集合的概述

集合的体系

五，Collection

概述：是单列集合的顶层接口，在定义所有单列集合一些共性功能。要想使用里面的资源必须找他的实现类，接下来学习他的资源使用 ArrayList 这个实现类来调用

常用方法：

代码示例一

all方法: 批量操作

代码示例二

第一种遍历方式：数组法【不常用】

代码示例

第二种遍历方式：迭代器遍历

代码示例