标题第二周总结+力扣五题
流程控制
1.顺序控制语句
按照代码的顺序进行执行
2.选择结构
（1）if选择语句
比如if、if else、if（）{if else }else{if else}等都属于选择结构。
if常用的语法格式为
if(表达式){
语句块1；
}else{
语句块2；
}
这个语法的意思是：当条件式成立时，执行语句1，否则执行语句2。
使用场景：用于区间值的判定，也可以用于固定值的判定，浮点类型的变量不合适作用于if语句的判定。
（2）switch语句
switch语句是一个多分支语句，也叫开关语句
switch语句的语法结构形式：
switch(变量名称或条件表达式){
case 判断常量1: {程序段1; break;}
case 判断常量2: {程序段2; break;}
.
.
.
case 判断常量n: {程序段n; break;}
[default: {程序段n+1;}]
}
switch语句首先计算表达式的值，如果表达式的值和某个case后面的判断常量相同，就执行该case里的若干语句，直到break语句为止。若没有一个判断常量与表达式的值相同，则执行default后边的若干语句。default语句块可以缺省。
使用场景：适用于固定值的判断
3.循环结构
（1）while语句
while语句的基本语法结构为：
while(循环条件表达式){
循环体；
}
首先，while语句执行条件表达式，它返回一个boolean值。如果条件表达式返回true，则执行大括号中的循环体语句。然后继续测试条件表达式并执行循环体代码，直到条件表达式返回false。
（2）do…while语句
do…while语句的基本语法结构为：
do{
循环体；
}while(循环条件表达式)
先执行一次do语句，然后再判断while的条件表达式。如果表达式为true，则继续执行do里面语句
如果表达式为false，则跳出循环。
do…while语句与while语句的区别在于：
do…while会先执行一次循环体，所以do…while的循环体至少被执行一次。
（3）for语句
for循环语句的语法：
for(循环变量赋初值;循环条件;增量表达式;){
循环体；
}
首先执行循环变量赋初值，完成必要的初始化；再判断循环条件，若条件满足，则进入循环体中执行语句；循环体执行完之后，紧接着执行for语句中的增量表达式，以便改变循环条件，这样一轮循环就结束了。第二轮循环又从判断条件开始，若满足，则执行循环体，否则跳出整个for语句执行后续语句。
方法
相当于c语言中的函数
一般情况下语法为：
修饰符 返回类型 方法名 (参数类型 参数名){
...
方法体;
...
return 返回值;
}
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型 ：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。
数组
1.数组的作用
当进行连续创建同一类型变量时，这种操作属于重复性的操作，可以通过数组来解决这种问题
2.数组的定义：
（1）动态定义一个数组
int [] a = new int[30];
数组类型 [数组的标识] 变量名称 = new 数组的类型[长度];
数组的动态定义时，如果数组是基本数据类型，那么基本数据类型的默认值是什么，数组的默认值就是什么 ；如果数组的类型是引用数据类型，那么默认值均为null。
（2）静态定义一个数组
int [] b = new int[]{0,1,2,3,4};
数组类型 [数组的标识] 变量名称 = new 数组的类型[]{数组元素};
不论哪种定义方法，数组都是定长的。
（3）数组元素的访问
可以通过数组的下标去获取数组中的元素， 数组的下标从零开始 index= length -1; 下标 = 数组的长度-1;
程序运行报错ArrayIndexOutOfBoundsException则表示数组下标越界异常。
数组遍历：
for (int i = 0; i < b.length; i++) {
System.out.println(b[i]);
}
（4）数组的工具类Arrays
数组属于引用数据类型 ，当打印数组对象时，打印的结果是数组地址。为了通过打印看到数组的内容，我们
需要借助数组的工具类 名称：Arrays ，可以使用Arrays.toString() 把数组转换成字符串，以字符串的形式去显示数组的内容。
3.排序
在Java中提供一个快速排序的方法 Arrays.sort();
（1）选择排序
每一趟（例如第i趟）在后面的 n-i+1 个待排序元素中选取关键字最小的元素，作为有序子序列的第i个元素，直到第 n-1 趟做完，待排序元素只剩下一个，就不用再选了。
（2）冒泡排序
让数组当中相邻的两个数进行比较，数组当中比较小的数值向下沉，数值比较大的向上浮，外层for循环控制循环次数，内层for循环控制相邻的两个元素进行比较。
’（3）反转排序
从数组最左边即第0个元素开始，依次和从数组最右边算起的的对应元素进行交换。
（4）插入排序
对于数组中的第i个元素，将他们左边的相邻元素依次进行比较，如果某个元素小于左边的元素，则将它们进行位置交换。
4.数组复制
使用System.arrayCopy(参数1,参数2,参数3,参数4,参数5)方法。
public class Exe1 {
```java
public static void main(String[] args) {
String a[] = new String[] {"1","2","3","4","5"};
String b[] = new String[] {"a","b","c","d","e"};
//System.arraycopy(a,0,b,0,a.length-4);// 1,b,c,d,e
//System.arraycopy(a,0,b,0,a.length-1); //1,2,3,4,e
// System.arraycopy(a,0,b,0,1); //1,b,c,4,5
// System.arraycopy(a,3,b,3,2);
System.arraycopy(a,0,b,0,1); //1,b,3,d,5
System.arraycopy(a,2,b,2,1);
System.arraycopy(a,4,b,4,1);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
}
}
参数1：源数组 复制的是源数组
参数2：源数组的起始位置
参数3：目标数组 被粘贴的对象
参数4：目标数组的起始位置
参数5：则表示复制长度
5.二维数组
（1）结构上类似于表格
（2） 如何定义：
动态定义：
int [] [] a=new int[2][3];
静态定义：
```java
int [] [] a = new int[][]{[0,1],[1,2]};
（3）基本用法
int [] [] a = new int[2][3];
int [] b [] = new int[2][3];
int c[][] = new int[2][3];
a[0][0] = 0;
a[0][1] = 1;
a[1][0] = 2;
a[1][1] = 3;
for (int i = 0; i < c.length; i++) {
for (int j = 0; j < c.length; j++) {
System.out.println(a[i][j]);
}
}
面向对象
1.面向对象和面向过程
（1）面向过程
根据业务的流程，把整个流程业务一步步的执行，一步步的写出来，所有的代码可以出现在一个类中。
public static void main(String[] args){
//从头到尾的在main函数中写相应的代码
}
缺点：
- 代码都在一起 不利于维护和扩展
- 大大增加开发的工作量
- 成本高
（2）面向对象
把整个项目的流程进行模块化
模块化思想：
针对某一个业务逻辑的时候 ，只需要考虑业务逻辑里面需要的业务流程即可 ，与这个业务逻辑无关的模块，交给相应的人员去考虑。
优点：
- 模块与模块相独立，彼此之间不会产生直接的影响，松耦合关系
- 通过调用或访问这样的方式把各模块连接在一起
- 利于维护，利于扩展
- 轻量级(更利于代码的重复利用)，较少代码冗余
2.对象
万物皆为对象
英文名称：Object Oriented
在Java语言中Object被看成是对象，是所有对象的主体
3.类
从多个对象当中抽象出来的共同的特征，可以把这种特性称之为类----class，类值得是一类事物。
类的一般形式：
public class 类名{
成员变量;
成员方法;
}
通常在一个类中，一般以名词作为类的属性存在（成员变量），以动词作为类的方法存在(成员方法)。
4.对象
对象就是类的具体化。
（1）对象的创建
一般格式：
类名 对象名 = new 类名([参数列表]);
该表达式隐藏了对象声明、实例化和初始化三部分。
（2）对象的调用
通过运算符 “.” 实现对对象自己的变量访问和方法调用。
访问对象的变量一般访问格式为：
对象名.成员变量;
调用对象成员方法格式：
对象名.方法名([参数列表]);
5.构造方法
构造方法是一个特殊的方法，主要用于初始化新创建 的对象。
（1）构造方法的特性
- 构造方法的名称一定和类名相同
- 构造方法没有返回值
- 创建对象时构造方法被调用
- 构造方法不能是静态的
（2）有参构造方法和无参构造方法
一个类可以创建多个构造方法，当类中含有多个构造方法时，会根据参数的不同来决定使用哪个构造方法进行初始化。
（3）this关键字
表示当前类的引用。
引用：引用指向哪个类 那么当前的引用指向的就是哪个类的对象。
6.面向对象特征之封装
正常去访问一个属性的时候，p.name这样的方式去进行访问，但是有些是比较的隐私，不能让其他类随意的访问 ，将name属性进行私有化，使用private关键字进行修饰 其他类对name这个属性就没有访问权限，但是又需要给某些类一个使用的权限，只能通过提供方法来解决这个问题 通过使用set和get方法来对name属性进行设置和获取。
访问修饰符：
- public 公共的 （任何地方都可以对变量进行访问）
- private 私有的 （只能在本类中访问）
力扣五题
- 3的幂
题目：给定一个整数，写一个函数来判断它是否是 3 的幂次方。
示例 1:
输入: 27
输出: true
示例 2:
输入: 0
输出: false
解题思路：
除了0，1之外，一个数如果是3的幂，那么使用这个数一直除以3，每一次除完都不会有余数，对得到的结果再进行除以3，重复判断是否有余数，直到除为1；如果一个数不断除以3过程中余数不为0，则表示该数不为3的幂。我们可以采用递归的方法进行求解。
代码实现：
public boolean isPowerOfThree(int n) {
if(n==1) {
return true;
}
if(n%3!=0||n==0 ) {
return false;
}
return isPowerOfThree1(n/3);
}
2.各位相加
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。
示例:
输入: 38
输出: 2
解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。
解题思路：
可以使用循环的方法进行求解。如果输入的数num为0，则直接返回sum为0；如果输入的数不为0，则对它进行除10操作，商为num，取得获得的余数，累加进sum中，一直循环直到把每位上的数都加入sum中，每位数都累加完成后num会变为0；跳出循环，再对取得的sum值进行操作，当sum为个位数则输出，如果大于9则再次重复类似于对数num的操作取得每位数相加的结果，完成后再判断直到sum小于10，跳出循环，输出sum。
代码实现：
public int addDigits(int num) {
int sum=0;
while(num!=0){
sum=sum+num%10;
num=num/10;
}
while(sum>=10){
int s=0;
while(sum!=0){
s=sum+sum%10;
sum=sum/10;
}
sum=s;
}
return sum;
}
3.泰波那契序列 Tn 定义如下：
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
给你整数 n，请返回第 n 个泰波那契数 Tn 的值。
示例 1：
输入：n = 4
输出：4
解释：
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4
示例 2：
输入：n = 25
输出：1389537
解题思路：递归，类似于斐波那契数列，但是要注意n的范围。
代码实现：
public int tribonacci(int n) {
if(n==0){
return 0;
}
if(n==1){
return 1;
}
if(n==2){
return 1;
}
if(n>2){
return tribonacci(n-1)+tribonacci(n-2)+tribonacci(n-3);
}
return 0;
}
4.整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
思路：定义一个变量c存储反转后的数初始为0，对输入的数x进行除10操作，商再次赋值给x，取得的余数加上c*10再赋值给c，每进行一次循环，从最低位开始便有一位数进行了进行了一次反转，直到全部反转完毕。
代码：
public int reverse(int x) {
int c=0;
while(x!=0){
c=c*10+x%10;
x=x/10;
}
return c;
}
5.回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
思路：首先排除负数和10的倍数，其余的数可以借鉴上述整数反转的方法，将输入的数字与反转之后的数字进行比较。
代码：
public boolean isPalindrome(int x) {
if(x==0){
return true;
}else if(x<0&&x%10==0){
return false;
}else{
int a = x;
int b = 0;
int c = 0;
while(a!=0){
b = a%10;
c = c*10+b;
a = a/10;
}
return c==x;
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
