xxxMapper.xml

数组倒序

1. int[] arr =  new int[]{1,2,3,4,5};

for(int i=0,j=arr.length; i < j;i++,j--){
        int temp = arr[j]；
        arr[j] = arr[i];
        arr[i] = temp;
}

2.

for(int i=0;i<arr1.length/2;i++){ 
     int temp = arr[arr.length-1-i];   
     arr[arr.length-1-i] = arr[i];   
     arr[i] = temp;
     }

冒泡排序：

import java.util.Scanner;
public class f2{
     public static void main(String[] args){ 
     // ToDo 冒泡排序   
     long start = System.currentTimeMillis();
     Scanner s = new Scanner(System.in);    
     int num;  
     System.out.println("请输入数组元素个数:");  
     num = s.nextInt(); 
     int[] arr = new int[num];
     System.out.println("请输入数组元素:");
     for(int i=0;i<arr.length;i++){  
           arr[i] = s.nextInt(); 
      }    
      // ToDo 前面所有的数都排序完后，最后一个数就不用判断了  
     for(int i=0;i<arr.length-1;i++){          
     //ToDo 由于下面if判断i+1，所以循环条件是j<arr.length-1，否则会报错    
     // ToDo 每次排序都会少一个数，所以是j<arr.length-1-i  
     for(int j=0;j<arr.length-1-i;j++){ 
            if(arr[j]>arr[j+1]){             
                 int temp = arr[j+1];      
                 arr[j+1] = arr[j];   
                 arr[j] = temp;   
                 }   
               } 
             }  
     System.out.println("排序后的元素为:");   
     for(int i=0;i<arr.length;i++){  
     System.out.print(arr[i]+"\t"); 、
     }   
     System.out.println();
     long end = System.currentTimeMillis();   
     System.out.println("程序运行时间:"+(end-start)); 
     }
  }

Arrays 数组工具类

equals 比较两个数组的元素是否完全相同

toString 输入显示数组的具体元素

fill 将数组所有元素重新赋值，赋值为参数2

sort 底层元素用的快速排序

binarySearch 二分法查找

数组常见异常：

数组下角标越界异常：

ArrayIndexOutOfBoundsException

空指针异常：

NullpointerException

UUID

发表于 2020-02-12 更新于 2020-02-22 分类于杂点
本文字数： 2.2k

前言

UUID 是通用唯一识别码（Universally Unique Identifier）的缩写，是一种软件建构的标准，亦为开放软件基金会组织在分布式计算环境领域的一部分。其目的，是让分布式系统中的所有元素，都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定。如此一来，每个人都可以创建不与其它人冲突的UUID。在这样的情况下，就不需考虑数据库创建时的名称重复问题。目前最广泛应用的UUID，是微软公司的全局唯一标识符（GUID），而其他重要的应用，则有Linux ext2/ext3文件系统、LUKS加密分区、GNOME、KDE、Mac OS X等等。另外我们也可以在e2fsprogs包中的UUID库找到实现。

阅读全文 »

java8新特性

发表于 2020-02-11 更新于 2020-02-12 分类于 java
本文字数： 1.2k

一、Lambda 表达式的基础语法 :java8中引入了新的操作符“->” 该操作符称为箭头操作符或Lambda操作符

箭头操作符 Lambda 表达式拆分为两部分:
左侧：Lambda 表达式的参数列表
右侧：Lambda 表达式所需执行的功能,即 Lambda 体

语法格式一:无参数,无返回值

() -> System.out.println("Hello Lambda");

语法格式二:有一个参数,并且无返回值
```
(x) -> System.out.println(x);
```
语法格式三:若只有一个参数,小括号可以省略不写
```
x -> System.out.println(x);
```

语法格式四:有两个以上的参数,有返回值,并且Lambda体中有多条语句

Comparator<Integer> com = (x,y) -> {
    System.out.println("函数式接口");
    return Integer.compare(x,y);
  };

语法格式五:若Lambda体中只有一条语句,return和大括号都可以省略不写
语法格式六:Lambda表达式的参数列表的数据类型可以省略不写,因为JVM编译器通过上下文推断出,数据类型,即“类型推断”
```
(Integer x,Integer y) -> Integer.compare(x,y)；
```

上联:左右遇一括号略
下联:左侧推断类型省
横批:能省则省

二: Lambda 表达式需要“函数式接口”的支持

函数式接口:接口中只有一个抽象方法的接口,称为函数式接口。可以使用@FunctionalInterface 修饰
可以检查是否是函数接口

Java8内置的四大核心函数式接口

Consumer : 消费型接口
void accept(T t);

Supplier<T> : 供给型接口
           T get();    

Function<T,R> : 函数型接口
           R apply(T t);

Predicate<T> : 断言型接口
           boolean test(T t);

一.方法引用:若Lambda体中的内容有方法已经实现了,我们可以使用”方法引用”
(可以理解为方法引用是Lambda表达式的另一种体现)

主要有三种语法格式:

对象::实例方法名

类::静态方法名

类::实例方法名

注意:
1).Lambda体中调用方法的参数列表与返回值类型,要与函数式接口中的抽象方法的函数列表和返回值类型保持一致！
2).②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

二.构造器引用
格式:
ClassName::New

注意:需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致！(个数)

三:数组引用:
Type::new

day11

发表于 2020-02-11 更新于 2020-02-12 分类于 java
本文字数： 2k

面向对象的特性之二: 继承性 what ? why ? how ?

　　1.继承性的好处:

　　　①减少了代码的冗余，提高了代码的复用性

　　　②更好的扩展性

　　　③为多态的使用提供了前提

　　2.格式:class A extends B extends:继承,(延展,扩展) 子类(SubClass):A 父类(SuperClass,超类,基类):B

　　3.说明:子类A继承父类B以后,就获取了父类中声明的结构:属性，方法

　　　　3.1 不管父类中的属性或方法或权限如何，子类都可以获取到

　　　　3.2 但是由于封装性的影响,可能在子类中不能直接调用父类中的权限较小的属性或方法

　　4.子类可以可以在继承父类的基础之上,提供自己特有的属性和方法

　　　区别于:集合与子集

　　5.子类和父类是相对的概念

　　　子类通过继承，可以获取直接父类以及所有的间接父类中声明的所有属性或方法

　　　一个父类可以被多个子类所继承

　　　子类只能声明一个父类—->java类的单继承类

　　6.

　　　6.1 如果一个类没显示的继承一个类的话，则其父类为：java.lang.Object类

　　　6.2 任何一个类(java.lang.Object 类)都能直接或者间接的继承于java.lang.Object类

　　　6.3 任何一个类在继承java.lang.Object 之后，就获取了Object类中声明的属性和方法

　方法的重写(override / overwrite)

　　　1.定义:子类在继承了父类以后，可以对父类中的同名同参数的方法进行“覆盖”或“覆写”

　　　2.重写以后，如果我们创建子类的对象，通过子类的对象调用子父类中同名的方法，执行的的是子类重写

　　　　类的方法

　　　3.子类重写的方法，父类被重写的方法

　　　　方法的声明:权限修饰符返回值类型方法名(形参列表) throws 异常的类型{ }

　　　　子类重写的方法与父类被重写方法的方法名和形参列表相同

　　　　子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

　　　　特别的，子类不能重写父类中声明private的方法(因为子类中看不到)

　　　　子类重写方法的返回值类型不大于父类被重写方法的返回值类型

　　举例: 1.父类方法的返回值类型是void，子类想重写，一定也是void

　　　　2.父类方法的返回值类型是A，子类重写父类方法，返回值是类型A或类型A的子类，不能是类型A的父类

　　　　　子类重写的方法抛出的异常类型不大于父类被或重写方法抛出的异常类型

规则: 子类与父类中同名同参数的方法，必须同时声明为static(不是重写)或非static（即为重写）

super 关键字的使用:

　　1.super 理解为:父类的

　　2.super 可以用来调用属性,方法,构造器

　　3.super属性,方法

　　　3.1 有了继承以后我们可以在子类的方法或者构造器中，可以通过“super.属性”或者“super.方法”的方法,显示的调用父类中声明的属性或者方法。但是很多情况下，我们都可以省略“super.”

　　　3.2 如果子类和父类中出现了同名的属性，那抹我们在子类中调用父类同名的属性的的话，必须使用“super.”的方法

　　　说明:子类的属性不会覆盖父类中同名的属性。在堆空间中，两个属性都会存在

　　　3.3 如果子类重写了父类的方法，那抹我们在子类中调用父类被重写的方法，必须用“super.”的方法

　　4.super 调用构造器: super(形参列表)

　　　4.1 在子类的构造器的首行，显示的使用“super(形参列表)”的方式,调用父类指定的构造器

　　　4.2 针对于子类的某一个构造器而言，最多只能声明一个“super(形参列表)”

　　　4.3 在子类的构造器的首行，要抹使用“this(形参列表)”,要抹使用“super(形参列表)”,不能同时出现

　　　4.4 在子类构造器的首行，既没有显示的使用”this(形参列表)”，也没有显示的使用“super(形参列表)”，那抹默认提供的是：“super()”

　　　4.5 在子类的多个构造器中，至少有一个构造器的首行使用了“super(形参列表)”

子类对象实例化的全过程：

　　1.结果上:(继承性) 子类在继承父类以后，就获取了所有的父类中声明的属性和方法

　　2.过程上: 我们在实力化子类对象的过程中，一定会直接或间接调用父类的构造器，以及父类的父类的构造器…. 直到调用到java.lang.Object的空参构造器，正因为加载了这些父类的结构，所以,在子类对象的内存中才有所有父类中声明的属性或方法

说明:在子类对象整个实例化过程中，只创建了唯一的一个对象，即为当前的子类对象

面向对象的特征三:多态性的使用

多态性:可以理解为一个事物的多种形态
广义上多态性的体现:

①方法的重写和重载 ②子类对象的多态性
狭义上多态性的体现: 子类对象的多态性
子类对象的多态性:父类的引用指向子类的对象(子类的对象赋给父类的引用)
多态的应用场景

　虚拟方法调用:编译时,认为调用的方法是父类的,但是当运行时，实际上执行的是子类重写父类的方法

　总结:多态中方法的调用:编译看左边，运行看右边。
多态性,只适用于方法 !
多态性使用的前提:①类的继承关系 ②要有方法的重写

day10

发表于 2020-02-11 更新于 2020-02-12 分类于 java
本文字数： 1.3k

类的成员之3：构造器(constructor,构造方法) construct:建造，建设

　1.构造器的作用：①创建类的对象 ②初始化对象的属性

　2.说明：

　　①如果在定义一个类时，没有显示的声明构造器，那抹系统会显示的提供的一个无参的构造器

　　②如何去声明一个类的构造器：格式：权限修饰符类名（形参列表）{}

　　③如果我们在类中一旦定义构造器，那抹系统不再提供默认的无参构造器了

　　④类的多个构造器之间，彼此构成重载

　　⑤总结:类中，一定有会构造器！

　3.关于类中属性赋值的先后顺序：

　　①默认初始化 - ②显示初始化 - ③构造器中初始化 || ④通过“对象.属性”或“对象.方法”，给属性赋值

　　①默认初始化

　　②显示初始化

　　③构造器中初始化

　　④通过“对象.属性”或“对象.方法”，给属性赋值

javaBean 如下标准java类

类是公共的
有一个无参的公共的的构造器
有属性，且有对应的get，set方法

this 关键字的使用 :

　1.this : 可以理解为:当前对象或正在创建的对象

　2.this 可以用来调用:属性,方法,构造器

　3.this 调用属性,方法

在方法中，通过this.属性或者 this.方法的方式，表示调用当前正在创建的对象的指定属性或方法。

但是通常的情况下，我们都省略了“this.”。但是如果方法的形参和当前正在创建的对象的属性名相同

的情况下，我们必须显示的使用this.变量的方式，表明此变量是属性而非形参

在构造器中，通过this.属性或者 this.方法的方式，表示调用当前正在创建的对象的指定属性或方法。

但是通常的情况下，我们都省略了“this.”。但是如果构造器的形参和当前正在创建的对象的属性名相同的情况下，我们必须显示的使用this.变量的方式，表明此变量是属性而非形参

　4.this 调用构造器

　　　可以在类的构造器中this (形参列表) 的方式，调用本类中重载其他的构造器

明确:构造器中不能通过this(形参列表)的方式，调用自身构造器　　

　　　如果一个类中声明了N个构造器，则最多有N-1个构造器使用了this(形参列表)

　　　this(形参列表) 必须声明在构造器的首行

　　　在类的构造器中，最多只能声明一个this(形参列表)

一：package 关键字的使用

　　package：包

　　1.为了方便的对项目中的类,进行统一的管理,提供了包的概念

　　2.声明在源文件的首行

　　3.遵循标识符的命名规则和规范:xxxxyyyzzz

　　4.命名时每“.”一次,代表着一层文件目录

二：import 关键字的使用 import:导入

　　1.可以在源文件中使用import来导入执定包下的类或接口

　　2.声明在类的结构和包的声明之间

　　3.如果需要在源文件中导入多个类或接口，则并列声明处即可

　　4.比如：import java.util.* ,表示可以导入util下的所有类和接口

　　5.如果使用的类或接口是java.lang下定义的，则可以省略import 语句

　　6.如果使用的类或者是当前包定义的，则可以省略import语句

　　7.如果一个类中使用了不同包下的同名类，则必须通过全类名（完整的路径）的方法进行区分调用

　　8.import static 可以导入指定类的静态属性或者方法

　　9.如果已经声明导入A包下的结构（如:import java.a*）,但是如果导入A包下的子包下的类或接口，仍需要导入声明

day12

发表于 2020-02-11 更新于 2020-02-12 分类于 java
本文字数： 786

equals 方法的使用

1.java.lang.Object 类中的equals()方法的定义:

public boolean equals(Object obj){

return(this == obj);

}

说明:Object 类中equals()比较两个对象的引用地址是否相同，（或:比较两个引用是否指向同一个对象实体）

2.像String,Date,File,包装类重写了Object类的方法，比较两个对象中的实体内容是否相等

3.对于自定义类来讲,如果没有重写Object类中equals（）方法，仍然比较两个对象的引用地址是否相同

4.一般情况下，在开发中一旦调用了自定义了的equals()，通常是重写以后的equals()方法

5.重写equals()方法的规则:比较两个对象的属性是否都相等

面试题: == 和 equals() 区别 ?

　　　　== :使用范围:可以操作基本数据类型和引用数据类型

　　　　　　如果操作的是基本数据类型:比较两个基本数据类型变量的值是否相等

　　　　　　如果操作的是引用数据类型:比较两个引用的地址是否相同

　　　　equals:使用范围:只适用于引用数据类型

　　　　具体的使用:见上面的1-5

toString()的使用:

1.java.lang.Object 类中toString()定义如下:

public String toString(){

return getClass().getName()+”@”+Integer.toHexString(hashCode());

}

2.当我们打印一个对象的引用时，实际上就是调用了toString方法

3.像String,Date,File,包装类等重写了Object类中的toString方法，返回其代表的具体内容

4.对于自定义类而言，如果我们没有重写object类中toString方法，则返回的仍然是地址值

如果重写了的话，重写规则:返回当前对象的属性信息

day1

发表于 2020-02-11 更新于 2020-02-20 分类于 java
本文字数： 1.2k

注释：

单行注释

//

多行注释(不可以嵌套)

/**/

文档注释（java特有）

println 换行

print 不换行

在一个源文件种不允许定义两个相同的类

关键字：具有特殊意义的字符串

特点：关键字都小写

保留字：现在不是关键字，以后可能作为关键字使用

标识符：程序员定义的变量名，函数名

标识符的命名规则：

由26个英文字母大小写组成，0~9，_或$组成
数字不可以开头
不可以使用关键字或者保留字，但能包含关键字和保留字
严格区分大小写，长度无限制
不能包含空格

标识符的命名规范：

　包名：多单词组成时所有字母都小写

　类名，接口名：多单词组成时所有单词首字母大写（大驼峰）

　变量名，方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个

　　　　　单词首字母大写（小驼峰）

　常量名：所有字母都大写，多单词组成时每个单词之间用下划线链接

变量分类：

角度1：按数据类型来分

　　　　基本数据类型：整型：byte（1）/ short（2字节）/ int（4字节）/ long（8字节）

　　　　　　　　　　　通常我们定义整形变量定义int

　　　　　　　　　　　如果定义long型变量后缀必须加l/L

　　　　　　　　　　　long ll = 1234 可以的，可以理解为自动类型提升

　　　　　　　　　　　浮点型：float （4字节） / double（8字节）

　　　　　　　　　　　通常我们定义浮点型变量定义double

　　　　　　　　　　　从存储数据的表数范围上讲，float的范围比long还要大

　　　　　　　　　　　如果定义float型变量后缀必须加f/F

　　　　　　　　　　　字符型：char（2字节）

　　　　　　　　　　　 ‘ ’声明

　　　　　　　　　　　char 不同的表示方式：　

　　　　　　　　　　　　　1.声明一个普通字符

　　　　　　　　　　　　　2.声明一个转义字符

　　　　　　　　　　　　　3.使用Unicode 码(\u16进制）

　　　　　　　　　　　布尔类型：boolean

　　　　　　　　　　　　　　true/ false

　　　　　　　　　　　常在流程控制中使用

　　　　引用数据类型：类 / 接口 / 数组

　　　注意String属于引用数据类型

角度2：按在类种声明的位置不同来分

　　　　成员变量 vs 局部变量

整型常量默认是int

浮点型默认是double

适用范围：除了boolean之外，对其他（7种）数据类型都适用

运算规则：byte 、char、short –>int–> long –>float –>double

特别的：byte short char三者之间做运算时，结果是int型(防止溢出)

自动类型提升：

容量小的数据类型和容量大的数据类型变量做运算，运算结果为容量大的数据类型（容量指存储范围的大小，而非储存空间大小）

强制数据类型转换：自动类型提升的逆过程

容量大的数据类型变量如果想转换为容量小的数据类型变量，就需要强制类型

转换符进行转换

强制类型转换符（）

String类与基本数据类型（8种）变量之间的运算

String 类属于引用数据类型的变量

String类型的变量值使用一对“ ”括起来表示

String类与基本数据类型（8种）变量之间只能做链接运算：+

String类与基本数据类型（8种）变量做运算的结果就是String

算术运算符：

　　- */ % (前)++ （后)++ (前)– (后)–
　　- 取余：% ：余数的符号与被模数的符号相同