今天开始复习之后的内容，复习到哪儿，算哪儿了，大致就是数组、java类和对象那一块了。

Java 数组

什么是数组？

数组是有序的元素序列。
若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。
数组是用于储存多个相同类型数据的集合。
在 编程语言中数组是重要的数据结构之一。

数组的特点：

1、数组是相同数据类型元素的集合。
2、数组中的各元素的存储是有先后顺序的，它们在内存中按照这个先后顺序连续存放在一起。
3、数组存放的数据类型可以是任何数据类型，包括基本数据类型、引用类型、数组（也就是数组中套数组，二维数组，三维数组等）
4、数组长度一旦创建就不能修改，只能存放固定长度的数据，如果超过这个长度会报数组下标越界的erro。
其实数组本身就是一个对象，java中对象是存放在堆中的，所以数组对象是存放在堆中的。

数组优缺点：

优点：
1、数组根据下标访问元素的效率非常快。
2、可以表示一组数据。
缺点：
1、数组长度固定，不能自动扩容。
2、只能存放单一的数据类型。
3、数组根据内容查找元素效率比较低。需要逐个比较。
4、插入元素和删除元素的效率比较低，因为可能要移动大量的元素。

数据基本语法：

1、声明数组：
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

int[] myList;         // 首选的方法

int myList[];         //  效果相同，但不是首选方法

2、声明并创建数组：
int[] mylist = new int[5]; // 创建数组并声明数组的长度。
int[] myArray = {1,2,3,4,5}; // 创建数组并初始化数据。
上实例吧！

public class ArrayStudy {
    public static void main(String[] args) {

        int[] mylist = new int[5];    // 创建数组并声明数组的长度。
        // 因为数组没有相对应的 add()等方法，所以只能通过下标去对数组添加、修改、查询数据。
        mylist[0] = 1;
        mylist[1] = 2;
        mylist[2] = 3;
        mylist[3] = 4;
        mylist[4] = 5;
        System.out.print("mylist[0] = " + mylist[0] + "\t");
        System.out.print("mylist[1] = " + mylist[1] + "\t");
        System.out.print("mylist[2] = " + mylist[2] + "\t");
        System.out.print("mylist[3] = " + mylist[3] + "\t");
        System.out.print("mylist[4] = " + mylist[4] + "\n");
        // 查看数组长度 用length属性去查看
        System.out.println("mylist.length = " + mylist.length);
        // 修改数组中的数组，通过下标去修改
        mylist[2] = 8;
        System.out.println("mylist[2]修改后的值 = " + mylist[2] );

        System.out.println();

        int[] myArray = {1,2,3,4,5};
        System.out.print("myArray[0] = " +myArray[0] + "\t");
        System.out.print("myArray[1] = " +myArray[1] + "\t");
        System.out.print("myArray[2] = " +myArray[2] + "\t");
        System.out.print("myArray[3] = " +myArray[3] + "\t");
        System.out.print("myArray[4] = " +myArray[4] + "\n");
        // 查询数组长度
        System.out.println("查看myArray数组长度 = " + myArray.length);

        // 因为通过下标一个一个的取，比较不方便，如果长度很大呢？所以用到循环也叫遍历
        for (int i = 0; i<myArray.length;i++){  // 或者i<= myArray.length - 1
            System.out.print(myArray[i] + "\t");
        }
        System.out.println();

        // 增强for循环,这种方便些直接取值
        for (int i :myArray) {
            System.out.print(i + "\t");
        }
        System.out.println();

        // 求数组中的和
        int sum = 0;
        for (int num :myArray){
            sum += num;
        }
        System.out.println("对数组中的数据求和：" + sum);

    }
}

xiabiaoyuejie.jpg

实际项目中用到的数组不是很多，面试的时候可能会问一些排序的问题，自己找时间练习下就好了，而且只有初级的工程师才会被问到吧！中级和高级问到的概率不是很大。有但是不多，主要的都是关注技术，能否适合公司的项目。

数组排序算法

Java中常用的数组排序算法，有冒泡排序、快速排序、选择排序、插入排序、希尔算法、并归排序算法、堆排序算法
1、冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端，也就是轻泡上浮。

public class ArraySortStudy {
    public static void main(String[] args) {

        int temp;
        int[] arr = {8,5,9,6,1,3,4,2,7};
        for (int i =0;i< arr.length;i++){
            for (int j=0;j<arr.length-1-i;j++){
                if (arr[j] > arr[j + 1]){ // arr[0] = 8 ; arr[1] = 5; 8 > 5 true
                    temp = arr[j]; // temp = arr[0] 8 temp赋值 = 8；
                    arr[j] = arr[j + 1]; // arr[0] = arr[0+1] arr[1] 因为arr[0] 等于8 所以要后移，所以下标+1
                    arr[j + 1] = temp; // arr[0+1] = 8; 数字大的往后移了一个下标，把大的值赋给arr[j + 1]
                }
            }
        }

        for (int i :arr){
            System.out.print(i + "\t");
        }
        System.out.println();
    }
}

可以优化，自己去优化，可以写个方法封装下。

冒泡.gif

冒泡静态.png

2、选择排序

public class ArraySortStudy {
    public static void main(String[] args) {

        int temp;
        int[] arr = {8,5,9,6,1,3,4,2,7};
        for (int i =0;i< arr.length;i++){
            for (int j=i+1;j<arr.length;j++){
                if (arr[i] > arr[j]){
                    temp = arr[j];  // temp = 5
                    arr[j] = arr[i]; // arr[j] = 8
                    arr[i] = temp; // arr[i] = 5
                }
            }
        }

        for (int i :arr){
            System.out.print(i + "\t");
        }
        System.out.println();
    }
}

其余的排序可以自行去练习。

多维数组

多维数组就是数组中嵌套数组。
语法：
type[][] typeName = new type[typeLength1][typeLength2];
例如：
String[][] str = new String[3][4];
int[][] a = new int[2][3];

String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
通过 sort 方法,按升序：

        int[] brr = {8,5,9,6,1,3,4,2,7};
        Arrays.sort(brr);
        for (int b : brr){
            System.out.print(b + "\t");
        }
        System.out.println();

1   2   3   4   5   6   7   8   9   

Process finished with exit code 0

Java 对象和类

对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
总体来说 类就是一类的统称比如人，分中国人、外国人，男人、女人统称，对象就比如具体的某个人，他有行为能力，比如跑步、吃饭等。

一个类中包含描述信息，和函数也叫方法，就是行为，能做什么，我们希望写这个方法去做什么？是有动作的。
类：访问关键字 class 类名{}
函数：访问关键字 返回值类型 方法名称(参数列表){} 需要在类中定义。
例如:

public class Person{
String p_name;
String p_age;

public static void main(String[] args){ // 程序入口，static静态
  // 在主函数main函数中调用函数
  printName();
}

// 自定义函数
public static void printName(){
  System.out.println("张三李四王二麻子");
}
}

张三李四王二麻子

Process finished with exit code 0

一个类可以包含以下类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

一个类可以拥有多个方法，在上面的例子中可以加入：eat()、run()、sleep() 等方法。

public class Person {
    // 成员变量  类中的所有方法都可以使用
    String p_name;
    // 成员变量
    String p_age;
    // 这是类变量，也叫静态变量，private是私有的
    private static String p_addr = "北京市";

    public static void main(String[] args){ // 程序入口，static静态
        // 在主函数main函数中调用函数
        printName();
        eat();
        run();
        sleep();
    }

    // 自定义函数
    public static void printName(){
        // 静态变量属于类，直接用类.变量名 调用  Person.p_addr
        System.out.println("张三李四王二麻子" + "   地址：" + Person.p_addr);
    }

    public static void eat(){
        // 局部变量，方法执行完，生命周期结束，会被回收
        String str = "外卖到了";
        System.out.println(str + "开始吃饭");

    }

    public static void run(){
        System.out.println("睡觉之前去跑几公里");
    }

    public static void sleep(){
        System.out.println("跑步回来，洗完澡，开始睡觉");
    }


}

张三李四王二麻子   地址：北京市
外卖到了开始吃饭
睡觉之前去跑几公里
跑步回来，洗完澡，开始睡觉

Process finished with exit code 0

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

创建对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法:

/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

public class Person {
    // 成员变量  类中的所有方法都可以使用
    String p_name;
    // 成员变量
    String p_age;
    // 这是类变量，也叫静态变量，private是私有的
    private static String p_addr = "北京市";

    // 自定义函数
    public static void printName(String name,String age){
        // 静态变量属于类，直接用类.变量名 调用  Person.p_addr
        System.out.println("姓名：" + name + " 年龄：" + age + "   地址：" + Person.p_addr);
    }

    public static void eat(){
        // 局部变量，方法执行完，生命周期结束，会被回收
        String str = "外卖到了";
        System.out.println(str + "开始吃饭");

    }

    public static void run(){
        System.out.println("睡觉之前去跑几公里");
    }

    public static void sleep(){
        System.out.println("跑步回来，洗完澡，开始睡觉");
    }


}

public class TestMain {
    public static void main(String[] args){ // 程序入口，static静态
        // 创建对象
        Person person = new Person();
        // 为类中的属性进行赋值
        person.p_age = "28";
        person.p_name = "张三";

        // 通过创建的对象调用类中的方法
        person.printName(person.p_age,person.p_name);
        person.eat();
        person.run();
        person.sleep();
    }
}

姓名：28 年龄：张三   地址：北京市
外卖到了开始吃饭
睡觉之前去跑几公里
跑步回来，洗完澡，开始睡觉

Process finished with exit code 0

• 一个源文件中只能有一个 public 类
• 一个源文件可以有多个非 public 类
• 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
• 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
• import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。这些将在访问控制章节介绍。

除了上面提到的几种类型，Java 还有一些特殊的类，如：内部类、匿名类。

Java 包

包主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

import 语句

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

import java.util.Random;// 导入的包

public class TestMain {
    public static void main(String[] args){ // 程序入口，static静态

        // 创建Random对象，需要导包不然报错
        Random r = new Random(); 
        // 打印生成的随机数
        System.out.println(r.nextInt(10));
    }
}

2

Process finished with exit code 0

Java 修饰符

Java语言提供了很多修饰符，主要分为以下两类：
访问修饰符
非访问修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端。

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected:对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

访问.jpg

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。

static 修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final 修饰符

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。一般用做常量。

abstract 修饰符

抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法
抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

public synchronized void showDetails(){
.......
}

用于多线程。

transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

public transient int limit = 55;   // 不会持久化
public int b; // 持久化

volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

接下来介绍下常用的Java内置类：

Java String 类

字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

创建字符串

// 用构造函数创建字符串：
String str2=new String("Runoob");
// String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：
String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。

字符串长度

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.baidu.com";
        int len = site.length();
        System.out.println( "百度地址长度: " + len );
   }
}

public class StringDemo {
    public static void main(String[] args) {

        String url = "www.baidu.com";
        // 打印字符串长度
        System.out.println(url.length());
        // 字符串是否包含匹配的字符串
        System.out.println(url.contains("ba"));
        // 在字符串后面拼接addr
        System.out.println(url.concat("addr"));
        // 字符串转换成大写
        System.out.println(url.toUpperCase());

    }
}

String有很多方法，操作字符串的时候需要可以自己去看下API。

创建格式化字符串

我们知道输出格式化数字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

public class RunoobTest{
    public static void main(String args[]){
        StringBuilder sb = new StringBuilder(10);
        sb.append("Runoob..");
        System.out.println(sb);  
        sb.append("!");
        System.out.println(sb); 
        sb.insert(8, "Java");
        System.out.println(sb); 
        sb.delete(5,8);
        System.out.println(sb);  
    }
}

StringBuffer .jpg

StringBuffer 2.jpg

Java Number & Math 类

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

包装类.jpg

public class Test{
 
   public static void main(String[] args){
      Integer x = 5;
      x =  x + 10;
      System.out.println(x); 
   }
}

15

Java Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}

90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值： 0.7853981633974483
π/2的角度值：90.0
3.141592653589793

Java Character 类

Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值。

char ch = 'a';
 
// Unicode 字符表示形式
char uniChar = '\u039A'; 
 
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情况。为了解决这个问题，Java语言为内置数据类型char提供了包装类Character类。
Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象，例如：

Character ch = new Character('a');
// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
 
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');

转义序列

前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。

转义字符.jpg

public class Test {
 
   public static void main(String[] args) {
      String str = "你好";
      System.out.println(str  + "你好" + "\t");
      System.out.println(str  + "你好" + "\n");
      System.out.println(str  + "你好" + "\r");
   }
}

Java 日期时间

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。

// Date( )
// Date(long millisec)

import java.util.Date;
  
public class DateDemo {
   public static void main(String[] args) {
       // 初始化 Date 对象
       Date date = new Date();
        
       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());

      // SimpleDateFormat 格式化日期
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
      System.out.println("当前时间为: " + ft.format(dNow));
   }
}

简单介绍下这些类，需要的自己去查下对应的API就可以了。
本次就复习到这了，下次开始复习Java面向对象那一块了。