Java学习笔记2

array类

方法	说明
String toString(int[] a)	打印数组元素的值 ，传入参数为待打印数组
void sort(int[] a)	数组元素的排序 ，引用类型需实现Comparable
int binarySearch(long[] a, long key)	二分法查找指定元素，返回查找元素的下标
void fill(long[] a, long val)	对数组进行填充

这些方法里的变量类型可以是所有数据类型，Arrays中有很多重载。
注意这里的toString方法，与Object的toString是不同的，并不是重写了Object的toString，而是带有参数的重载。
Arrays类的实例：

public class Test {
	public static void main(String[] args) {
		String[] myList = { "b", "c", "d", "a" };
        System.out.println(myList); //直接打印数组
        System.out.println(Arrays.toString(myList)); // 打印数组元素的值
        Arrays.sort(myList);//使用sort方法进行排序
        System.out.println(Arrays.toString(myList)); // 打印数组元素的值；
        System.out.println("该元素的索引："+Arrays.binarySearch(myList, "c"));//二分法查找指定元素
        Arrays.fill(myList, 1, 3, "e");  //将[1,3)索引的元素替换为"e";
        System.out.println(Arrays.toString(myList));
	}
}
--------------------------------------------------------------------------------------------------
输出结果为：
[Ljava.lang.String;@7852e922
[b, c, d, a]
[a, b, c, d]
该元素的索引：2
[a, e, e, d]

多维数组

二维及多维数组，就是数组当中的每一个元素，又是一个数组。(俄罗斯套娃…)但是实际开发中用的非常少。最多到二维数组(一般使用容器，二维数组用的都很少)。声明与一维数组类似；初始化时，先初始化第一层，再第二层，以此类推；遍历时就使用嵌套循环，一层一层取出来。实例：
下面展示一些 内联代码片。

	   String[][] s = null; // 声明
	   s = new String[2][]; //初始化该数组，预先定义指定的空间大小：数组中存了2个数组元素。
	   						//new String[2][]，中的第二个[]中并不不能约束第二维的元素个数
	   s[0] = new String[2];		 //初始化数组中的第0号元素，该元素也为数组
	   s[1] = new String[3];		 //初始化数组中的第1号元素，该元素也为数组
	   
	   s[0][0] = new String("Good");  //为二维数组的第0号元素的0号元素赋值
	   s[0][1] = new String("Luck");  //...一个个来
	   s[1][0] = new String("to");
	   s[1][1] = new String("you");
	   s[1][2] = new String("!");
	   
	   for (String[] strings : s) {
		   for (String strings2 : strings) {  //嵌套foreach来遍历
			 System.out.println(strings2);
		   }
	   }
-------------------------------------------
输出结果为：
Good
Luck
to
you
!

关于嵌套循环遍历可能还好理解一些，关于声明，我这里用个人理解再阐述一下：
如果我们想声明一个一维数组，那么：

• 首先，它是一个数组，所以我们写： [ ] 来表示是数组。
• 然后数组中装的是int类型，所以我们再写：[ ] int 来表示是装int类型的数组。
• 再给这个声明数组取个名字，所以我们写：[ ] int myList，来表示是一个叫myList的，装int类型的数组。但是 这样写不好看，所以Java规定了，我们得变形成：int[ ] myList 来声明。
• 以上声明已经完成，然后我们进行初始化：int[ ] myList = new int[2]；注意，这里使用了new关键字，能被new的都是对象，而int时基本数据类型，不能被new。我们可以理解为：new [ ]，是new的一个数组，然后数组中为 int 类型，元素个数为 2 ，即 new [ ] int 2，变形：new int[2]，即int[ ] myList = new int[2]；自此分配空间完成，可以进行赋值。

那当我们想声明一个二维数组，参照上面的步骤：

• 首先，它是一个数组，所以我们写： [ ] 来表示是数组。
• 然后数组中装的是数组类型，所以我们再写：[ ] [ ] 来表示是装int类型的数组。
• 此时第二个数组还没声明完，此数组中装的是int类型，所以我们再写：[ ] [ ] int 来表示是装int类型的数组。（若想声明更高维数组，则把int改为 [ ] 重复此步骤，直到最后一维数组内装元素的类型不再是数组）
• 再给这个声明数组取个名字，所以我们写：[ ] [ ] int myList。根据Java的语法格式规定，所以变形为：int[ ] [ ] myList 来声明。
• 以上声明已经完成，然后我们进行初始化：先 new 第一维数组： new [ ] ，数组中为数组类型：[ ] ，元素个数为2，即 new [ ] [ ] 2 。但数组是不能单独存在的，必须是某一个数据类型的数组，所以加上最后一维的数据类型：int。即写为：new int[2][ ]。注意，此时第二维数组并没有被new出来，一个new关键字不能new出两个对象。所有我们还要继续new第二维。
• 初始化一个数组：new int[3]；（三个元素）再将new出的数组赋值给这个二维数组，即：myList[0] = new int[3];
• 再初始化一个数组：new int[4]；（四个元素）再将new出的数组赋值给这个二维数组，即：myList[1] = new int[4];至此，myList数组全部装满，这才分配空间完成，可以进行赋值。

java面向对象编程思想的理解

什么是面向对象编程
可以这样理解，对象是事物存在的实体，如，猪、狗，花早等都是对象，对象由两部分组成。面向对象编程的三大特点：继承，多态，类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。
如何在Java中实现面向对象编程

• 通过类：类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。
• 封装：是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想，用户只能通过对外提供的接口访问数据。
• 多态：是指允许不同类的对象对同一消息做出响应，根据对象创建实例的不同调用不同的方法，本质是编译时和运行时才决定对象的行为。
  这里分为两个知识点：
  静态分派，方法的重载，编译时决定
  动态分派，方法重写，运行时决定。
  多态的特点：可替换性，灵活性，扩展性，统一编码风格。
• 继承：继承是指从已有的类中派生新的类，新的类能够吸收已有类的数据属性和行为，并能够扩展新的功能。
  特点：可扩展性，代码复用。

方法重载与重写

方法的定义是由五个要素组成的，分别是修饰符、返回值类型、方法名称、方法参数以及方法体。那么将方法名称和方法参数放在一起，则称为这个方法的签名，简称方法签名。
在Java中，同一个类中两个不同的方法不可以出现相同的方法签名。也就是说方法签名是方法唯一的标识。如果相同那么就是同一个方法，Java不允许声明相同的方法，否则编译不通过。

• 方法的签名
  将方法名称和方法参数放在一起，则称为这个方法的签名，简称方法签名。
• 方法的重载(Overload)
  前面说的方法签名是指方法名称和参数列表的统称。如果同一个类中，两个方法的方法名称相同，但是参数列表不同，那么就规定这是方法的重载。
  1、方法重载定义
  在同一个类中，方法名称相同，参数列表不同，方法体不同，则称为方法重载。
  在Java中，方法的重载是发生在编译期间的。编译器会在编译期间，将根据方法的参数列表自动绑定调用哪个方法。所以重载归结为一句话：“重载看参数”。
  方法的重载规则如下：
  <1>方法名称必须相同，参数列表必须不同
  <2>参数列表不同指的是参数个数、参数类型、参数类型位置的不同的，而不是指参数名称、参数位置不同。
  <3>重载只和方法名称以及参数列表有关，与其他的无关。
  <4>重载发生在同一个类中，或者子类中
• 方法的重写(Override)
  1、重写的定义
  方法的重写：发生在父子类中，方法名称必须相同，方法参数必须相同，方法体不同。
  在Java中，方法的重写是发生在运行期间的。编译器会在运行期间，将根据调用方法的对象类型自动绑定调用哪个方法。
  所以重写归结为一句话：“重写看对象”。
  2、重写的规则
  重写规则：“两同两小一大”。
  <1>两同：方法名称相同，方法参数相同
  <2>两小：返回值类型，子类小于等于父类返回值类型
  返回值类型分为三种情况：
  void类型：当方法无返回值时，重写时候，父子类返回值类型必须相同，都为void类型。
  基本数据类型：当方法返回值是基本数据类型时，重写时候，方法的返回值类型必须一致。
  引用数据类型：当方法返回值是引用数据类型时，重写时候，方法的返回值类型子类必须小于或等于父类的方法返回值类型。
  <3>两小：方法抛出的异常：子类小于等于父类抛出的异常
  <4>一大：方法的访问修饰符：子类大于父类的访问修饰符
• 理解“重载看参数，重写看对象

Java类和对象的理解

面向对象的思想是如何在java展现
就是通过类和对象类是一组相关的属性和行为的集合。是一个抽象的概念。 对象是该类事物的具体表现形式。具体存在的个体。
成员变量事物的属性成员方法事物的行为上面我们说了这几个概念，应该怎么理解
类就是对一些具有共性特征，并且行为相似的个体的描述。比如小李和老张都有姓名、年龄、身高、体重等一些属性，并且两人都能够进行聊天、运动等相似的行为。由于这两个人具有这些共性的地方，所以我们把它抽象出来，定义为一个类——人类，而小李、老王正是这个类中的个体（对象），而个体才是真正具体的存在，光提到人类，你只知道应该有哪些属性行为，但你不知道他具体的一些值，比如你知道他属于“人类”所以他应该有姓名，年龄等属性，但你并不知道他具体叫什么，年龄多大了。而小李和老王这两个具体的对象，却能够实实在在的知道老王今年30岁了、身高175等值。
结合上面的例子再总结一下：成员变量就是用来描述这个类的属性的，比如人类应该拥有姓名，年龄等属性成员方法就是用来描述事物的行为的，比如人类能够聊天、运动等行为
简单来说，对象是类的特例，拥有类有的基本属性，并且被具体赋值过

Java正则表达式

这篇文章主要介绍一下Java中的正则表达式，以及如何使用正则表达式的使用。

• 正则表达式介绍
  正则表达式也称为规则表达式，在Java中常简写为regex、regexp或者RE。正则表达式本质上也是一个字符串，只是它用于规定某个字符串的规则。
  正则表达式作用：用于检测字符串的文本规则。例如：检索、替换那些符合某个模式(规则)的文本。

• Java中正则表达式的使用
  1、创建正则表达式规则

// 1.创建正则表达式规则
String regex = "hello" ;

2、创建解析正则表达式规则的对象
Pattern类是位于java.util.regex包下的。该类中提供了一个静态方法compile()，用于解析正则表达式规则的，该方法返回一个Pattern实例。

// 2.创建解析正则表达式的对象
Pattern p = Pattern. compile(regex);

3、匹配目标字符串
调用Pattern类中的matcher()方法，用于匹配目标字符串。该方法返回一个Matcher实例对象。

// 3.匹配目标字符串
String str = "hello, I' am
tom.";
Matcher m = p. matcher(str);

4、处理匹配结果
在匹配目标字符串后，返回的Matcher实例中，包含了对应的匹配结果信息。
<1>find()方法：判断是否匹配到对应的字符串。返回值类型：boolean。

// 4.处理匹配结果
boolean b = m. find( );
Sys tem. out. pr intln(”是否匹配到字符串:”+ b);
"C: \Program Files\Java\jdk1.8.0_ _211\bin'
是否匹配到字符串: true

注：当目标字符串中，有多个满足正则规则时，find()方法匹配到第一个时，就不会继续往下匹配。
如果需要得到所有的匹配结果，则可以循环进行判断。
<2>start()方法：返回匹配成功时，字符串的开始下标或索引。返回值类型：int。

//匹配成功的开始下标
int start = m.start( );
System. out. println("start=" + start);
"C: \Program Files \Java\jdk1.8.
是否匹配到字符串: true
start=0

<3>end()方法：返回匹配成功时，字符串的结束下标的下一个索引。返回值类型：int。

//匹配成功的结束下标的下一个索引
int end = m. end( );
Sys tem. out. pr intln("end=" + end);
"C: \Program Files \Java\jdk1.8.
是否匹配到字符串: true
start=0
end=5

注：目标字符串是"hello, I’am tom."，对应的正则表达式是"hello"，所以匹配成功的开始下标是0，对应的结束下标是4，但是end()方法是指向结束下标的下一个索引位置，故end等于5。
<4>group()方法：返回匹配成功的字符串。返回值类型：String。

//返回匹配成功的字符串
String group = m.group( );
Sys tem. out. pr intln(" group=" + group);
"C: \Program Files \Java\jdk1.8.
是否匹配到字符串: true
start=0
end=5
group=hello

<5>metches()方法：判断整体匹配是否成功。即：当目标字符串从头到尾完全满足正则表达式时，才会返回true。

// 整体匹配
boolean matches = m. matches( );
Sys tem. out. pr intln(”是否满足整体匹配:+ matches);
是否匹配到字符串: true
start=0
end=5
group=hello
是否满足整体匹配: false

由于正则表达式是"hello"，目标字符串是"hello, I’am tom."，所以不满足整体匹配，返回false。

• 正则表达式字符集以及数量词
  1、中括号[]约定字符集范围
  要表示0到9之间的数字，只需要写：[0123456789]即可表示0-9之间的某一个数字。
  数字范围：[0-9]。
  小写字母：[a-z]。
  大写字母：[A-Z]。
  大写小写：[a-zA-Z]。
  2、字符集缩写
  数字缩写：\d 表示[0-9]之间的某一个数字。
  字符缩写：\w 表示字母、数字、下划线、汉字中的某一个。
  空白缩写：\s 表示空白。
  匹配开始：^ 表示字符串开始。
  匹配结束：$ 表示字符串结束。
  任意字符：. 点表示匹配任意一个字符。
  3、数量词
  x{n} 表示x必须出现n次。
  x{n,m} 表示x至少出现n次，至多出现m次。
  x{n,} 表示x至少出现n次，最多不限。
  x* 表示x出现0到多次。
  x+ 表示x出现1到多次。
  x? 表示x出现0次或1次。
  4、分组
  () 表示分组。
  | 表示或者。
• String中的正则表达式方法
  1、boolean matches(regex)方法
  matches()方法全局匹配。匹配成功，返回true，否则，返回false。
  注：该方法只返回检测结果，不返回匹配成功后的文本。

public static void main(String[] args) {
// 匹配电话号码
String phone = "+86 12345678901";
//匹配规则
String regex = "\\+(86)\\s\\d{11}";
// 匹配结果
boolean b = phone . matches( regex);
System. out. println("b=" + b);
}

2、String[] split(regex)方法
split()用于拆分字符串，将其拆分为字符串数组。

public static void main(String[] args) {
String str = "hello, world, jack";
//根据逗号拆分
按照逗号分割
String regex
String[] arr = str . split(regex);
System. out. pr intln(Arrays. toString(arr));
}

3、String replaceAll(regex, replacement)方法
replaceAll()方法用于根据regex，使用replacement字符串替换匹配到的字符串。
注：一般用于过滤敏感字符。