3.4 数组中涉及到的常见算法
1.数组元素的赋值（杨辉三角，回型数等）
杨辉三角
package atguigu.exer;
//杨辉三角
public class ArrayDemo2 {
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] arr = new int[10][];
//2.给数组的元素赋值
for(int i = 0;i < arr.length;i++){
arr[i] = new int[i + 1];
//2.1给首末元素赋值
arr[i][0] = 1;
arr[i][i] = 1;
//2.2给每行的非首末元素赋值
//if(i > 1){
for(int j = 1;j < arr[i].length - 1;j++){
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
//}
}
//3.遍历二维数组
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();
}
}
}
2.求数值型数组中元素的最大值，最小值，平均数，总和等
package com.atguigu.java;
/*
* [10.99]
* 公式:(int)(Math.random()*(99 - 10 + 1) + 10)
*/
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = (int)(Math.random()*(99 - 10 + 1) + 10);
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i]);
System.out.println();
}
//求数组元素的最大值
int maxValue = 0;
for(int i = 0;i < arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
System.out.println("最大值为： " + maxValue);
//求数组元素的最小值
int minValue = arr[0];
for(int i = 0;i < arr.length;i++){
if(minValue > arr[i]){
minValue = arr[i];
}
}
System.out.println("最小值为： " + minValue);
//求数组元素的总和
//sum
//求数组元素的平均数
//double avgValue = sum/arr.length;
}
}
3.数组的复制，反转，查找（线性查找，二分法查找）
复制，翻转，查找
package atguigu.exer;
public class ArrayExer1 {
public static void main(String[] args){
int[] arr1,arr2;
arr1 = new int[]{2,3,5,7,11,13,17,19};
//显示arr1的内容
for(int i = 0;i < arr1.length;i++){
System.out.print(arr1[i] + "\t");
}
//复制
arr2 = new int[arr1.length];
for(int i = 0;i < arr2.length;i++){
arr2[i] = arr1[i];
}
//赋值arr2变量等于arr1
//不能称作数组的复制
//arr2 = arr1;
//修改arr2中的偶索引元素，使其等于索引值
for(int i = 0;i <arr2.length;i++){
if(i % 2 == 0){
arr2[i] = i;
}
}
System.out.println();
for(int i = 0;i < arr1.length;i++){
System.out.print(arr1[i] + "\t");
//数组的反转
}
}
}package atguigu.exer;
public class ArrayExer2 {
public static void main(String[] args){
//数组的反转
String[] arr = new String[]{"a","b","c","d","e","f"};
for(int i = 0;i < arr.length / 2;i++){
String temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
//查找（搜索）
//线性查找：
System.out.println();
String dest = "b";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){
System.out.println("找到了指定元素，位置为: " + i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("很遗憾，没有找到");
}
System.out.println("*********************");
//二分法查找：(熟悉)
//前提：索要查找的数组必须有序。
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定元素，位置为： " + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else{//arr[middle] < dest1
head = middle + 1;
}
}
if(isFlag1){
System.out.println("没有找到");
}
}
}
4.排序算法
（1）时间复杂度：分析关键字的比较次数和记录的移动次数
（2）空间复杂度：分析排序算法中需要多少辅助内存
（3）稳定性：若两个记录A和B的关键字值相等，但排序后A,B的先后次序保持不变，则称这种排序算法是稳定的。
排序算法分类：内部排序和外部排序
需要借助外部存储器的叫做外部排序
冒泡排序
package com.atguigu.java;
/*
* 数组冒泡排序的实现
*/
public class BubbleSortTest {
public static void main(String[] args){
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
//冒号排序
for(int i = 0;i < arr.length - 1;i++){
for(int j = 0;j < arr.length - 1 - i;j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
}
}3.5 Arrays工具类的使用
package com.atguigu.java;
import java.util.Arrays;
/*
* java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
*
*
*/
public class ArraysTest {
public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1,arr2);
System.out.println(isEquals);
//2.String toString(int[] a )：输出数组信息
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中
Arrays.fill(arr1, 10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binary Search(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index > 0){
System.out.println(index);
}else{
System.out.println("没找到");
}
}
}
3.6 数组使用中的常见异常
1.数组角标越界的异常：ArrayIndexOutOfBoundsException
2.空指针异常：NullPointerException
4.面向对象
4.1 面向过程和面向对象
一、Java面向对象学习的三条主线：（第4-6章）
1.Java类及类的成员：属性，方法，构造器；代码块，内部类
2.面向对象的三大特征：封装性，继承性，多态性（抽象性）
3，其他关键字：this,super,static,final,abstract,interface,package,import等
“大处着眼，小处着手”
二、“人把大象装进冰箱”
1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
①把冰箱门打开
②抬起大象，塞进冰箱
③把冰箱门关闭
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做
三、面向对象的两个要素
- 类：是对一类事物的描述，是抽象的，概念上的定义
- 对象：是实际存在的该类事物的每个个体，因而也称为实例（instance）
面向对象程序设计的重点是类的设计
设计类，就是设计类的成员
/*
* 一、设计类，其实就是设计类的成员
*
* 属性 = 成员变量 = field = 域
* 方法 = 成员方法 = 函数 = method
*
*
* 创建类的对象 = 类的实例化
*
* 二、类和对象的使用（面向对象思想落地的实现）：
* 1.创建类：设计类的成员
* 2.创建类的对象
* 3.通过“对象.属性”或“对象.方法”调用对象的结构
*
* 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
* 意味着如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值。
*
* 四、对象的内存解析
*
*/
package com.atguigu.java;
//测试类
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//调用对象的结构：属性、方法
//调用属性：“对象、属性”
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法：“对象.方法”
p1.eat();
p1.sleep();
//*************************
Person p2 = new Person();
System.out.println(p2.name);//null
//********************
//将p1变量保存的对象地址赋给p3，导致p1,p3指向了堆空间中的同一个对象实体
Person p3 = p1;
System.out.println(p3.name);//Tom
p3.age = 10;
System.out.println(p1.age);
}
}
class Person{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat(){
System.out.println("人可以吃饭");
}
public void sleep(){
System.out.println("人可以睡觉");
}
} 类中属性的使用
package com.atguigu.java;
/*
* 类中属性的使用
*
* 属性(成员变量) VS 局部变量
* 1.相同点：
* 1.1 定义变量的格式：数据类型 变量名 = 变量值
* 1.2 先声明，后使用
* 1.3 变量都有其对应的作用域
* 2.不同点：
* 2.1 在类中声明的位置的不同
* 属性：直接定义在类的一对{}内
* 局部变量：声明在方法内， 方法形参，代码块内，构造器形参，构造器内部的变量
* 2.2关于权限修饰符的不同
* 属性：可以在声明属性时，指明其权限，使用权限修饰符。
* 常用的权限修饰符：private,public,缺省，protected ---->封装性
* 目前：大家声明属性时，都使用缺省就可以了
* 局部变量：不可以使用权限修饰符
*
* 2.3 默认初始化值的变化
* 属性：类的属性，根据其类型，都有默认初始化值
* 整型（byte,short,int,long）,0
* 浮点型（float,double）,0.0
* 字符型（char）:0
* 布尔型（boolean）:false
*
* 引用数据类型（类，数组，接口）：Null
*
* 局部变量：没有默认初始化值
* 意味着我们在调用局部变量之前，一定要显示赋值
* 特别地，形参在调用时，我们赋值即可
* 2.4 在内存中加载的位置，
* 属性：加载到堆空间中（非static）
* 局部变量：加载到栈空间
*/
public class UserTest {
}
class User{
//属性（或成员变量）
private String name;
public int age;
boolean isMale;
public void talk(String language){//形参,也是局部变量
System.out.println("我们使用" + language + "进行交流");
}
public void eat(){//局部变量
String food = "烙饼";
System.out.println("北方人喜欢吃: " + food);
}
}类中方法的使用和说明
package com.atguigu.java;
/*
* 类中方法的声明和使用
*
* 方法：描述类应该具有的功能
* 比如：Math类，sqrt()\random()
* Scanner类，nextXxx()
* Arrays类，sort()\binarySearch()
*
* 1.举例：
* public void eat(){}
* public void sleep(int hour){}
* public String getName(){}
* public String getNation(String nation){
*
* }
*
* 2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){
* 方法名
* }
* 注意：static,final,abstract来修饰的方法，后面再讲
*
* 3.说明：
* 3.1关于权限修饰符：
* java规定的4种权限修饰符：private,public,缺省，protected --->封装性再讲
* 3.2返回值类型：有返回值 vs 没有返回值
* 3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中需要使用
* return关键字来返回指定类型的变量或常量。
* 如果方法没有返回值，则方法声明时，使用void表示-通常没有返回值的方法中
* 就不需要使用return，如果使用的话，只能"return"表示结束此方法
* 3.2.2我们定义方法该不该有返回值？
* （1）题目要求
* （2）凭经验：具体问题具体分析
* 3.3方法名：属于标识符，遵循标识符的规则和规范，见名知意
* 3.4形参列表：方法可以声明0个，1个或多个形参
* 3.4.1格式：数据类型1 形参1，数据类型2，形参2，.....
*
* 3.4.2我们定义方法时，该不该定义形参
* ①题目要求
* ②凭经验，具体问题具体分析
* 3.5方法体：方法功能的体现
*
* 4.return关键字的使用 ：
* 1.适用范围：使用在方法体中
* 2.作用：（1）结束方法
* （2）针对于有返回值类型的方法，使用"return 数据" 方法返回所要的数据。
* （3）注意点：return关键字后面不可以声明执行语句
* 5.方法的使用中，可以调用当前类的属性或方法
* 特殊的：方法A中又调用了方法A，递归方法。
* 方法中不可以定义方法
*/
public class CustomerTest {
public static void main(String[] args){
//int[] arr = new int[]{1,2,7,5,4,3};
//cust1.sort(arr);
}
}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat(){
System.out.println("客户吃饭");
}
public void sleep(int hour){
System.out.println("休息了" + hour + "个小时");
}
public String getName(){
return name;
}
public String getNation(String nation){
String info = "我的国籍是：" + nation;
return info;
}
// public void sort(int[] arr){
// }
}
京公网安备 11010502036488号