今天开始复习之后的内容，复习到哪儿，算哪儿了，大致就是数组、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);
}
}
实际项目中用到的数组不是很多，面试的时候可能会问一些排序的问题，自己找时间练习下就好了，而且只有初级的工程师才会被问到吧！中级和高级问到的概率不是很大。有但是不多，主要的都是关注技术，能否适合公司的项目。
数组排序算法
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();
}
}
可以优化，自己去优化，可以写个方法封装下。
图片来源：https://blog.csdn.net/weixin_44541320/article/details/111641669
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:对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
非访问修饰符
为了实现一些其他的功能，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);
}
}
Java Number & Math 类
一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。
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');
转义序列
前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。
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面向对象那一块了。
