java数组
数组概念：保存多个相同数据类型的集合（容器柜子）。用到栈内存与堆内存。
Java虚拟机所管理的内存包括**方法区、虚拟机栈、本地方法栈、堆、程序计数器**等。
通常认为JVM中运行时数据存储包括堆和栈.
**栈指的是虚拟机栈**，或者说是虚拟栈中的局部变量表。栈中存放一些**基本类型的变量数据（int/short/long/byte/float/double/Boolean/char)和对象引用**。堆中主要存放对象，即通过new关键字创建的对象。
例子：数组引用变量是存放在栈内存中，数组元素是存放在堆内存中。
*堆内存的存放的是实体，栈内存存放的是虚拟变量。图所展示的是第一次引用的给num，第二次引用给num1，也就意味着将会将第一次的引用给切断。 *
知识点欠缺
1.1 一维数组
创建的两种语法：数据类型【】数组名称：建议使用。数据类型 数组名称【】；
初始化两种形式：先声明再赋值；先声明并赋值。
在创建的时候只给长度并给具体的值；
int [] num=new int [] {1,5,8,25}; int agges[]={1,3,4,5};
在创建的时候只给长度不给具体的值； int 【】num； num =new int [5];
| 数组的特点 | 数组的使用规则 |
|---|---|
| 1.元素个数称为数组长度。长度一旦确定，就不能改变。也就是说，一旦确定写好就不能删除。2、既能存储原始数据 ，又能存储对象类型；3、元素下标是从0开始。元素的位置是用下标表示。数组元素下标的最大值为：数组长度-1；4、数组可以作为对象处理。数组对象含有成员变量长度length;例如：nam.length.5、可以创建数组的数组。 | 1. 可以只给部分元素赋初值。2. 只能给元素逐个赋值，不能给数组整体赋值。3. 如不给可初始化的数组赋初值，则全部元素均为0值。（基本数据类型）4. 如给全部元素赋值，则在数组说明中， 可以不给出数组元素的个数。 |
| 数组长度的查看new.length | 数组的赋值： 根据数组的元素下标 |
| 数组的长度结果是int型的；int leng=num.length; 使用变量来接收数组的长度System.out.println(num2.length); 直接输出长度 | num1[0]=10;num1[2]=20; |
package com.xingyun.tiaojianyuju;
/**
* 获取一维数组的最小值
* 在类的主方法中创建一维数组，求数组中值最小的元素，并在控制台输出
* @author Administrator
*
*/
public class MinNum {
public static void main(String[] args) {
int [] arr = new int [] {6,2,0,57,36,17};
int min = arr[0];
for (int i = 0; i < arr.length-1; i++) {
if(min > arr[i+1]) {
min = arr[i+1];
}
}
System.out.println("最小值为： "+ min);
}
}
package com.xingyun.tiaojianyuju;
/**
* 求一维数组各元素的和
* 在类的主方法中使用数组存储1~10个整数，然后求出这10个数的和
* @author Administrator
*
*/
public class test {
public static void main(String[] args) {
int arr[]=new int[]{1,2,3,4,5,6,7,8,9,10};
int sum = 0;
for (int i = 0; i <= arr.length-1; i++) {
sum += arr[i];
}
System.out.println("1~10个数之和为:" + sum);
}
}
package com.xingyun.tiaojianyuju;
/**
* 在主方法中创建int型数组，并实现将各月的天数输出
* @author Administrator
*
*/
public class GetDay {
public static void main(String[] args) {
int day[] = new int [] {31,28,31,30,31,30,31,31,30,31,30,31};
for (int i = 0; i < day.length; i++) {
System.out.print((i+1) + "月有" +day[i] + "天" + "\t");
if((i+1)%3==0) {
System.out.println("\n");
}
}
}
}
1月有31天 2月有28天 3月有31天
4月有30天 5月有31天 6月有30天
7月有31天 8月有31天 9月有30天
10月有31天 11月有30天 12月有31天
1.2 二维数组
概念：二维数组就是每个基本单元是一维数组的一维数组。
二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标元素所在的列。
1.2.2
数组元素类型 数组名字[][]; 数组元素类型[][] 数组名字；
第一个中括号中的数字是一维数组的个数。第二个中括号中的数字是一维数组的长度。
给二维数组分配内存时，可以对其每一个一维数组单独分配内存，且分配的内存可以并不相同。
a = new int[2][];
a[0] = new int [2];
a[1] = new int [3];
应用举例子：
package com.xingyun.tiaojianyuju;
/**
* 在主方法中编写代码实现输出一个3行4列且所有元素都是0的矩阵
* 对于整型二维数组，创建成功后系统会赋给数组中每个元素初始化值0
* @author Administrator
*
*/
public class Matrix {
public static void main(String[] args) {
int [][]arr = new int [3][4];
for (int i = 0; i <arr.length; i++) {
for (int j = 0; j <arr[i].length; j++) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
结果如下：
0 0 0 0
0 0 0 0
0 0 0 0
package com.xingyun.tiaojianyuju;
/**
* 矩阵的转置：将矩阵的行列互换，把a[i][j]的值存储在元素a[j][i]的位置。转换前
* 是m*n维矩阵，转换后是n*m维矩阵。
* 要求是：在类的主方法中声明二维矩阵，然后将此矩阵进行转置运算，
* 并将结果在控制台输出
* @author Administrator
*
*/
public class ArrayRowColumnSwap {
private static void printArray(int [][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
public static void main(String[] args) {
int [][] arr = new int [][] {{1,2,3},{4,5,6},{7,8,9}};
System.out.println("转置前的矩阵如下： ");
printArray(arr);
int [][] arr1 = new int [arr.length][arr[0].length];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr1[j][i] = arr[i][j];
}
}
System.out.println("转置后的矩阵内容如下：" );
printArray(arr1);
}
}
转置前的矩阵如下：
1 2 3
4 5 6
7 8 9
转置后的矩阵内容如下：
1 4 7
2 5 8
3 6 9
package com.xingyun.tiaojianyuju;
/**
* 方阵的迹：也就是对角线上所有元素的和。
* 要求：在类的主方法中创建二维数组，然后求出二维方阵的迹，并在控制台上输出。
* @author Administrator
*
*/
public class Trace {
public static void main(String[] args) {
int [][]arr = new int [][] {{1,2,3},{4,5,6},{7,8,9}};
int sum = 0;
for (int j = 0; j < arr.length; j++) {
sum += arr[j][j];
}
System.out.println("对角线之和为：" +sum);
}
}
1.3 三维数组
三维数组的元素是二维数组，二维数组的元素是一维数组，每个元素使用arr[x][y][z]的格式表示，例如arr[0][1][2]就代表数6。
package com.xingyun.tiaojianyuju;
/**
* 在主方法中创建三维数组，并将三维数组在控制台输出
* @author Administrator
*
*/
public class Ransack {
public static void main(String[] args) {
int [][][] arr = new int [][][]{
{{1,2,3},{4,5,6}},
{{7,8,9},{10,11,12}},
{{13,14,15},{16,17,18}}
};
for (int i = 0; i < arr.length; i++) {
System.out.println("三维数组的第"+(i+1)+"个元素是一个"+arr[0].length+"数组");
for (int j = 0; j < arr[0].length; j++) {
for (int j2 = 0; j2 < arr[0][0].length; j2++) {
System.out.print(arr[i][j][j2]+"\t");
}
System.out.println();
}
}
}
}
结果如下：
三维数组的第1个元素是一个2数组
1 2 3
4 5 6
三维数组的第2个元素是一个2数组
7 8 9
10 11 12
三维数组的第3个元素是一个2数组
13 14 15
16 17 18
1.4 应用例子
1.2.1 杨辉三角
public class ThreeTrangle {
public static void main(String[] args) {
int arr[][]=new int[8][8];
//进行
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
//保证第一个和最后一个是1
arr[i][0]=arr[i][i]=1;
if (i>1&&j>0&&j<i) {
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
}
}
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
if (arr[i][j]!=0) {
System.out.print(arr[i][j]+" ");
}
}
System.out.println();
}
}
}
1.2.2 Arrays.sort的排序
public static void main(String[] args) {
int []arr= {1,56,25,78};
Arrays.sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
}
1.2.3 选择排序
public class choose_Arrays {
public static void main(String[] args) {
int[] str= {1,16,45,23,56,89};
int temp=0;
for (int i = 0; i < str.length; i++) {
for (int j = i+1; j < str.length; j++) {
if(str[i]>str[j]) {
temp=str[i];
str[i]=str[j];
str[j]=temp;
}
}
}
System.out.println("这是排序后的值");
for (int i : str) {
System.out.print(i+" ");
}
}
}
1.2.4 冒泡排序
public class ArraysSort {
public static void main(String[] args) {
int[] str = new int[] { 1, 16, 45, 23, 48, 75 };
int temp=0;
for (int i = 0; i < str.length; i++) {
for (int j = 0; j < str.length-1-i; j++) {
if(str[j]>str[j+1]) {
temp=str[j];
str[j]=str[j+1];
str[j+1]=temp;
}
}
}
System.out.println("这是排序后的值：");
for (int i : str) {
System.out.print(i+" ");
}
}
}
1.2.4 九九惩罚表
public class NineNineTable {
public static void main(String[] args) {
for (int i = 1; i <=9; i++) {
for (int j = 1; j <=i; j++) {
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println();
}
}
}
1.5 数组的基本操作
1.5.1 Arrays类
| fill(int[] a, int value)方法：填充替换数组元素。该方法通过各种重载形式完成任意类型的数组元素的替换。 | fill[int[]a,int fromIndex,int toIndex不包含,int value]方法： |
|---|---|
| copyOf(arr,int newIength)方法是复制数组至指定长度。 | copyOfRange(arr,int fromIndex,int endIndex不包含)：方法则将指定长度复制到一个新的数组中 |
package com.xingyun.tiaojianyuju;
import java.util.Arrays;
public class Cope {
public static void main(String[] args) {
int arr[] = new int[] {23,42,12,56,19};
int arr1[] = Arrays.copyOf(arr, 5);
for (int i = 0; i < arr1.length; i++) {
System.out.print("使用copyOf方法获得数组："+arr1[i] + "\t");
}
int arr2[] =Arrays.copyOfRange(arr, 2, 4);
System.out.println();
for (int i = 0; i < arr2.length; i++) {
System.out.print("使用copyOfRange方法获得的数组："+arr2[i] + "\t");
}
}
}
第一个方法：
package com.xingyun.tiaojianyuju;
import java.util.Arrays;
public class Swap {
public static void main(String[] args) {
int arr[] = new int[5];
Arrays.fill(arr, 3);
for (int i = 0; i < arr.length; i++) {
System.out.println("集合的所有元素为：" + arr[i]);
}
}
}
第二个方法：
package com.xingyun.tiaojianyuju;
import java.util.Arrays;
public class Displace {
public static void main(String[] args) {
int arr[] = new int[] {45,12,2,10,1};
Arrays.fill(arr, 2, 4, 6);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
1.6 注意常犯的错误
package com.xingyun.tiaojianyuju;
/**
* 存储相同的数据，一维数组和二维数组所占用的内存空间基本相同，
* 这种认识是错误的。
* @author Administrator
*
*/
public class OneArrayMemory {
public static void main(String[] args) {
//一维数组的创建和复制
int num1 = 1024*1024*2;
int [] arr=new int[num1];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
//获得占用内存总数，并将单位转换为MB
long memory1 = Runtime.getRuntime().totalMemory()/1024/1024;
System.out.println("用一维数组存储占用内存总量是：" + memory1);
int num2 = 1024*1024;
int [][] arr1=new int[num2][2];
for (int i = 0; i < arr1.length; i++) {
arr1[i][0] = i;
arr1[i][1] = i;
}
long memory2 = Runtime.getRuntime().totalMemory()/1024/1024;
System.out.println("用二维数组存储占用内存总量是：" + memory2);
}
}
面向对象
什么是基于对象？什么是面向对象？它们之间的区别是什么？
基于对象是使用对象，停留在把函数捆绑在结构内部的语言是基于对象的。但是无法利用现有的对象模板产生新的对象类型，继而产生新的对象，基于对象一般没有继承的特点。
基于对象并不是单独的理论，而是面向对象的初级阶段，就是只有封装。只能是把属性、方法放进类中，实例化对象调用。学习面向对象要从基础知识入手，学会定义类、接口的定义、继承。然后要深入细致的研究现实事物，把现实事物或是需求文档中的名词抽象出来生成类或属性，如果是主语，多半还要根据整句的描述生成方法，定义类结构。之所以叫抽象，是因为定义类成员时要忽略掉系统不需要的其它东西。慢慢你就发现原来写程序要不停的增删代码和重构。经验丰富了，就能设计出只增加代码，不修改、删除代码的类结构了。
要掌握面向对象技术不是一件容易的事，这要求我们对于所有的编程事务从“对象”的角度来考虑，是一种全新的思考问题的方法。
从过程编程到对象编程，应该是观念上的变化吧。通过学习了解我个人认为面向对象编程比较基本的看法就是把一个一个对象看过是一个一个的黑盒子，黑盒子提供一下方法，外部无需看到，只要注意对象就可以了。
什么是面向对象？什么是面向过程？他们各自的有缺点是什么？
1》面向对象指的是面向对象编程。
面向对象是模型化的，需抽象出一个类，这相当于一个封闭的盒子，在这里你拥有数据也拥有解决问题的方法。
面向对象的底层其实还是面向过程，把面向过程抽象成类，然后封装，方便我们使用的就是面向对象了。
2》面向过程是一种以过程为中心的编程思想
面向过程是具体化的，流程化的，解决一个问题，需要一步一步的分析，一步一步的实现。
优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较消耗资源。
缺点：不易维护、不易复用、不易扩展.
面向对象的特点
面向对象的三大特性：
1、封装：隐藏对象属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
2、继承：提高代码复用性；继承是多态的前提。
3、多态：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。
五大基本原则：
1、单一职责原则SRP(Single Responsibility Principle)
类的功能要单一，不能包罗万象，跟杂货铺似的。
2、开放封闭原则OCP(Open－Close Principle)：一个模块对于拓展是开放的，对于修改是封闭的。
3、里式替换原则LSP(the Liskov Substitution Principle LSP)
子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~
4、依赖倒置原则DIP(the Dependency Inversion Principle DIP)
高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。
5、接口分离原则ISP(the Interface Segregation Principle ISP)
设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。
一 什么是对象、类？
对象是通过new类得到的，所以我们说对象是类的一个具体实例。
类是一个特殊的对象
类（什么）-----------------------对象（谁）
类是具有相同属性和方法的对个对象的抽象。
属性-------------------静态部分（描述）----------------------变量
方法------------------动态部分（行为）-----------------------方法
二 对象怎么来的？
先有对象后有类。
1、类
创建一个学生类 class Student{ }
创建属性 可以赋值可以不赋值
//属性部分
String name;
int age;
String sex="男";
int sid;
//创建一个学生对象 必须在main方法中
Student stu =new Student();//在堆内存中创建
调用对象的属性 对象名.属性名
stu.name="张三";
stu.age=15;
stu.sid=123;
stu.sex="女";
System.out.println(stu.name+stu.age+stu.sex+stu.sid);
2、2 访问权限修饰符的作用范围
Class 类名{ } 在同一个java文件中可以创建多个不同类名的类，但是只能有一个用public修饰的。用public修饰的类名必须与java文件的名字一致。
Public 是什么？访问权限修饰符，
| Public 公共的 | Private 私有的 |
|---|---|
| Protected 受保护的 | 不写默认的 |
3.1 构造方法 -----创建对象时使用
a. 有参数构造方法 是在new对象给对象赋值，给对象的属性赋值。如果类中没有属性就不能创建有参数构造方法，参数的个数可以是多个。不要超过属性的个数。 参数的名字可以与你要赋值的属性的名字一致，如果一致的话必须使用this关键字来进行参数和属性的区分。如果不用this就必须将参数的名字和属性的名不一样，但是参数的类型必须与要赋值的属性一致。
public 类名(【有参数】){ java代码}
b. 无参数构造方法 创建对象的时候不赋值
public 类名(【无参数】){ java代码}
当类中没有任何构造方法的时候，会有一个默认的无参数构造方法，但是一旦类中有了有参数构造方法，就不会再有默认无参数构造方法。如果你在类中写了有参数构造方法，就一定要把无参数构造方法也显示的写出来。
c. 构造方法的调用
在创建对象的时候根据有没有传参数来调用
1 >new Person(); 根据你空号中是否传值，不传值代表调用的是无参数构造方法
如果传参数：根据参数的个数调用对应有参数构造方法，实际传的参数的类型必须与你要使用的有参数构造方法的参数类型以及类型的顺序一致
3.1.1 属性 ：描述对象或者类的静态部分 — 属性就是变量 数据类型 变量
数据类型可以是基本数据类型或者引用数据类型类（类类型）
属性分为全局属性和局部属性：
全局属性：归当前类 所有，会有默认值，可被当前所有 非静态static方法 调用。
局部属性：归当前区域（方法）所有，局部变量在使用前必须进行赋值，没有默认值。
当局部变量与全局变量名字相同时， 采取局部优先原则。
静态属性可以被非静态方法和静态方法直接调用。非静态属性只能被非静态方法直接调用。
3.2 方法的定义格式 ：
【访问限定符 限定方法的访问作用域 public 】 【修饰符static静态 final最终 abstract抽象】
返回值类型（可以是任何类型：基本、引用） 方法名（【参数…】可是任何类型并且多个）{方法体 java代码}
返回值类型： 有返回值，如果方法有返回值必须使用return关键字并且返回内容须与返回值类型一致 无返回值void
3.3 方法的使用 ：
如果方法没有使用***修饰符***进行定义，那么需要使用“对象.方法名（【参数】）；”进行调用；
方法的具体分为4类，解释如下：
a. 没返回值没有参数
//无参数无返回值方法
public void study() {
System.out.println("我在学习java");-
for(int i=1;i<10;i++) {
for(int j=1;j<=i;j++) {
System.out.print(i+"*"+j+"="+(i*j)+"\t");
}
System.out.println();
}
}
在调用方法的时候，只会执行方法体中的java代码
b. 没返回值有参数
public void study(String name ...) {
System.out.println(this.name+"在学习");
}
在调用方法的时候，需要传入与形式参数类型一样的实际参数。形式参数可以有多个，如果形参是多个的话，实际参数的个数以及参数类型必须一致。
c. 有返回值没参数
//有返回值类型没有参数的方法
public String study1() {
System.out.println("我在学习linux");
return "hello";【接收的时候比较特殊，需要注意情况】
}
在声明方法时，必须使用return关键字，并且必须放在方法体的最后一行。Return返回的内容必须与方法规定的返回值类型一致。如果没有return关键字程序就会报错。调用方法的时候返回值可以不接收，可以直接使用输出语句输出。如果要接收返回值必须使用与返回值类型一样的变量进行接收。
d. 有返回值有参数
//有参数有返回值的方法 返回值类型是对象类型 参数是对象类型的参数
public Student dedaoStu(Student stu) {
// Student stu = new Student();不需要去new对象了，直接调用。
System.out.println(stu.name);
return stu;
} 在调用时需传入对应的参数，使用return关键字。 参数的类型可以是类类型。
3.4 Static 静态修饰符
被static修饰的属性和方法属于类所有，可直接类名.方法名进行直接调用。
静态修饰符的使用：例如 Static 数据类型 属性名；----------------java中static修饰的是静态的对象，
| Static关键字的特点 | static的调用 |
|---|---|
| 1. 随着类的加载而加载。2. 优于对象存在，随着字节码的文件存在而存在。3. 被类的所有对象所共享.4. 可以通过类名调用.1》 非静态属性只能被非静态方法直接调用，静态属性可以被静态或非静态方法直接调用。2》 静态属性属于类的，非静态属性属于对象的。 | 2) Public static 返回值类型 方法名（【参数】）{} ；静态方法归类所有， 类名.方法名（【参数】）；非静态方法归对象所有。对象名.方法名（【参数】）；静态方法也可以被对象进行调用 |
| String类是一个特例：可以不用new对象就可以直接调用它自己的非静态方法。是因为它有一个叫做字符串池的空间。 |
代码块与静态代码块的区别
1、代码块
{
代码块-属于类所有，随着对象的创建被调用。每创建一次对象就会被调用一次。
}
2、静态代码块
Static{
静态代码块----在程序启动类被加载到内存中的时候就会被调用，并且只调用一次。
System.out.println("我是静态代码块");
}
3.4 对象的引用的三种写法
类的引用： 一个类可以被另外一个类当做属性来引用，被引用的就是该类的属性。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
