java学习总结2

26.do...while

初始化语句;

do {

    循环体语句;

    条件控制语句;

} while(条件判断语句);

        (先执行后判断)

27.无限循环

        循环一直停不下来,循环下不能再写其他代码。

        for(;;) {语句体;}

        while(true) {语句体;}

        do {语句体;} while(true);

28.跳转控制

        continue；结束本次循环，继续下次循环

        break;结束整个循环

29.随机数

•         步骤一:导包：import java.util.Random;导包的动作必须出现在类定义的上边
•         步骤二:创建对象：Random r = new Random( );(r为变量)
•         步骤三:生成随机数：int i= r.nextInt(bound:数字);(i为变量，右边括号里为随机数范围，0~数字-1，口诀：包头不包尾，包左不包右)

30.数组

        一种可存储同种数据类型的多个值的容器（需要结合隐式转换考虑），建议容器的类型和存储的数据类型保持一致。（格式：数据类型 [] 数组名 / 数据类型 数组名 []）；

31.静态初始化

        在内存中为数组容器开辟空间，并将数据存入容器的过程。

        格式：数据类型 [] 数组名=new 数据类型[]{元素1,元素2,元素3};

        简化格式：数据类型 [] 数组名={元素1,元素2,元素3};

32.地址值的格式含义

        eg. [D@776ec8df （习惯性将这个整体叫做数组的地址值）

•                 [:表示当前是一个数组
•                 D:表示当前数组里面的元素都是double类型的
•                 @:表示一个间隔符号。(固定格式)
•                 776ec8df:才是数组真正的地址值,(十六进制)

33.索引

        也叫下标、角标，从0开始，逐个+1增长，连续不间断

        （获取格式：数组名[索引] /存储格式：数组名[索引]=具体数据/变量）

34.数组遍历

        将数组中所有内容取出，取出后可以打印、求和、判断...（遍历不是打印！）一次循环尽量只做一件事。

        调用数组长度：数组名.length

        快速生成数组的遍历方式：数组名.fori

35.动态初始化

        初始化时只指定数组长度,由系统为数组分配初始值。

        （格式:数据类型[]数组名=new数据类型[数组长度];）

        数组默认初始化值的规律：

•                 整数类型:默认初始化值0
•                 小数类型:默认初始化值0.0
•                 字符类型:默认初始化值'/u0000’即空格
•                 布尔类型:默认初始化值 false
•                 引用数据类型:默认初始化值 null

        动静态初始化区别：动态手动指定数组长度,由系统给出默认初始化值。适合只明确元素个数,不明确具体数值的情况；静态手动指定数组元素,系统会根据元素个数,计算出数组的长度。适合明确了要操作的具体数据的情况。

36.内存分配

•         栈：方法运行时使用的内存,程序的主入口(main方法)，开始执行时会进栈,代码执行完毕会出栈
•         堆：存储对象或者数组,new来创建的,都存储在堆内存，每一块小空间都有地址值和各自的数据，当两个数组指向同一个小空间时,其中一个数组对小空间中的值发生了改变,那么其他数组再次访问的时候都是修改之后的结果了。
•         方法区：存储可以运行的class文件
•         本地方法栈：JVM在使用操作系统功能的时候使用,无关
•         寄存器：给CPU使用,无关

37.方法

        程序中最小的执行单元，重复的代码、具有独立功能的代码可以抽取到方法中，提高代码的复用性、可维护性。

        方法格式为：

Public static 返回值类型 方法名(参数) {

    方法体;

    return 返回值;（void类型无返回值）

}

        调用格式为：方法名();

        注意事项：

•                 看到方法进入方法，执行完毕回到调用处，方法不调用就不执行；
•                 方法与方法之间是平级关系,不能互相嵌套定义；
•                 编写顺序和执行顺序无关；
•                 返回值类型为void,表示该方法没有返回值,可以省略return语句，如果要编写return,表示结束方法，后面不能跟具体的数据；
•                 return语句下面不能编写代码,因为执行不到,属于无效代码；
•                 方法有返回值，必须要写return语句，表示结束方法和返回结果；
•                 方法调用时,参数的数量与类型必须与方法定义中小括号里面的变量一一对应。

38.形参和实参

        形参:全称形式参数,指方法定义中的参数。

        实参:全称实际参数,指方法调用中的参数。

        注意:方法调用时,形参和实参必须一一对应,否则程序将报错。

39.带返回值方法的调用

        返回值是方法运行的最终结果。

•         直接调用：方法名(实参);
•         赋值调用：整数类型 变量名=方法名(实参);
•         输出调用：System.out.println(方法名(实参));

40.方法的重载

        在同一个类中,定义了多个同名的方法,这些同名的方法具有同种的功能，每个方法具有不同的参数类型或参数个数,这些同名的方法,就构成了重载关系。即同一个类中,方法名相同,参数不同（个数不同、类型不同、顺序不同）的方法。与返回值无关。

        Java虚拟机会通过参数的不同来区分同名的方法，顺序不同可以构成重载,但不建议

41.基本、引用数据类型

•         基本数据类型：数据值存储在自己的空间中，特点:赋值给其他变量,赋的真实值。
•         引用数据类型:数据值存储在其他空间中，自己空间中存储的是地址值，特点:赋值给其他变量,赋的地址值。

42.自动抽取方法

        选中代码，然后ctrl+alt+M

43.修改关键词

        选中单词，然后shift+F6，修改单词

44.数组定义

        String[] args;中括号是数组类型的一部分,不能用String args[]的方式来定义。

45.二维数组静态初始化

•         格式：数据类型[][] 数组名=new 数据类型[][]{{元素1,元素2},{元素1,元素2}};
•         简化：数据类型[][] 数组名={{元素1,元素2},{元素1,元素2}};
•         元素访问：数组名[索引][索引];
•         遍历：先得到一维数组,再遍历一维数组获取元素

46.二维数组获取元素

        arr[i][j];

        arr是二维数组；i是二维数组的索引,获取出来的是里面的一维数组j是表示一维数组中的索引,获取出来的就是真正的元素

47.二维数组动态初始化

        （格式：数据类型[][] 数组名=new 数据类型[m][n];）

        m指这个二维数组,可以存放多少个一维数组，n指每一个一维数组,可以存放多少个元素

题解

1.给你一个字符串s，找到s中最长的回文子串。

char* longestPalindrome(char* s) {

    int len=strlen(s),max=0,p=0;

    for(int i=0;i<len;i++) {

        int left=i-1,right=i+1;

        while(left>=0&&right<len&&s[left]==s[right]) {

            left--;

            right++;

        }

        if(right-left+1-2>max) {

            max=right-left+1-2;

            p=left+1;

        }

    }

    for(int i=0;i<len;i++) {

        int left=i,right=i+1;

        while(left>=0&&right<len&&s[left]==s[right]) {

            left--;

            right++;

        }

        if(right-left+1-2>max) {

            max=right-left+1-2;

            p=left+1;

        }

    }

    s[p+max]='\0';

    return p+s;

}

回文有奇数和偶数两种，需要遍历两遍分别判断奇数回文和偶数回文，在当前回文左右两边都不超过字符串长度且左右两边相等的情况下，左右各扩散一位，然后更新回文长度，找到最长回文子串后，分配一个新的字符数组来存储它，最后返回字符数组的指针。

2.将一个给定字符串s根据给定的行数numRows，以从上往下、从左到右进行Z字形排列。比如输入字符串为"PAYPALISHIRING"行数为3时，排列如下：

P      A      H     N

A  P  L  S  I   I  G

Y      I       R

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。请你实现这个将字符串进行指定行数变换的函数。

char * convert(char * s, int numRows)

{

    int len=strlen(s);

    if(numRows==1||numRows>=len)

        return s;

    char *a=(char *)malloc(sizeof(char)*(len+1));

    int k=2*numRows-2,n=0;

    for(int i=0;i<numRows;i++) {

        for(int j = 0; j<len ; j++) {

            if(j%k==i||j%k==k-i)

                a[n++]=s[j];

        }

    }

    a[len]='\0';

    return a;

}

观察题目可知，每一行字母的所有下标其实是有规则的：

1.起始下标都是 行数；

2.第0层和第n-1层的下标间距总是k=2*numRows-2；

3.中间层的下标间距总是k-2*行数，2*行数交替。即：

0                      2n-2

1             2n-3  2n-1

2        2n-4       2n

...

n-2  n              3n-4

n-1                  3n-3

可见，遍历每一行，当元素下标除以k的余数为行数或k-行数时，将该元素存入新字符串，最后返回该字符串。

3.给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。假设环境不允许存储 64 位整数（有符号或无符号）。

int reverse(int x){

    int y=0;

    while(x) {

        if(y>INT_MAX/10||y<INT_MIN/10)

            return 0;

        y=y*10+x%10;

        x/=10;

    }

    return y;

}

因为环境不允许存储 64 位整数，所以当反转后的数溢出时，不能直接与范围比较是否溢出，由于反转时是从右往左依次取出x上的一位数，将该值加上原y值的10倍赋值给y，即原y值的10倍应小于最大值，大于最小值；同时除以10，即原y值应小于最大值的1/10，大于最小值的1/10，就能在不溢出的情况下判断最终反转数是否溢出。