Java变量+数组+基本算法

变量

1 概念
可以改变的数，称为变量。一般通过三部分来描述一个变量。变量类型，变量名，变量值。其中三部分都是可以改变的，根据需要来确定即可。

变量的使用原则：就近原则。尽量控制到最小范围。。

2 局部变量
定义在方法里，或者局部代码块中。

注意：必须手动初始化，来分配内存。如：int i=5;

作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。

3 成员变量
定义在类里。

注意：不用初始化，也会自动被初始化成默认值。

作用域是整个类中，类消失了，变量才释放。

4 测试

package cn.tedu.arrays;

 

public class Test2_Variable {

   

    //1、成员变量：在类里方法外是

    //作用范围就是整个类里

    //可以不初始化，也会有默认值

    int age = 20;

   

    int sum = 30;

   

    public static void main(String[] args) {

       //2局部变量：在方法里是

       //作用范围就是方法里，出了这个方法就不认识了

       //必须初始化

       int sum = 10;

       System.out.println(sum);//10

      

       //3、变量的就近原则，附近有同名的会去执行最近的

       System.out.println(sum);//10

    }

}

方法

1 概述
被命名的代码块，方法可以含参数可以不含参数

可以提高代码的复用性

1.2 形式

修饰符 返回值 方法名(【参数】){

   方法体;

}

3 demo1：方法调用

public class Test1_方法 {

       public static void main(String[] args) {

 

              System.out.println(1);

              f();

System.out.println(2);

       }

 

       private static void f() {

              System.out.println(3);//132

       }

 

}

­

4 demo2：方法参数

public class Test1_参数 {

       public static void main(String[] args) {

 

                     System.out.println(1);

                     f(2);

                     System.out.println(2);

              }

 

       static void f(int x){

              System.out.println(x*x);//142

       }

}

5 demo3：方法返回值

public class tt {

 

       public static void main(String[] args) {

              System.out.println(1);

             

              int num=f3(5);

              System.out.println(num);

             

              String str = f4("学习使我快乐");

              System.out.println(str);

             

              System.out.println(2);

       }

 

       public static String f4(String desc){

              return desc+",我信你个鬼";

       }

      

      

       public static int f3(int i){

              return i*10;

       }

             


}

2 方法的重载
2.1 概念
方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。

程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

2.2 demo1：数字求和

package day005;

 

public class Test5_方法重载 {

 

       public static void main(String[] args) {

              int a=10;

              int b=20;

              String name="lisi";

             

              f1();

              f1(a);

              f1(a,b);

              f1(a,b,name);

       }

 

       private static void f1(int a, int b, String name) {

              System.out.println(a+b+name);//30name

       }

 

       private static void f1() {

              System.out.println("f1()");

       }

 

       private static void f1(int a) {

              System.out.println(a);

       }

 

       private static void f1(int a, int b) {

              System.out.println(a+b);

       }     

}

2.3 demo2：数据的打印

3 数组

3.1 概念
数组Array是用于储存多个相同类型数据的集合。

想要获取数组中的元素值，可以通过元素的下标来获取，下标是从0开始的。

3.2 创建数组
一般分为动态初始化和静态初始化

动态初始化：int[] a = new int[5];
新建int[],长度是5
刚创建好的数组都是默认值0，int类型的数据默认值是0
把数组的地址值给变量a保存

静态初始化1：int[] a ={1,2,3,4,5,6,7,8};
静态初始化2：int[] a =new int[]{1,2,3,4,5};

3.3 练习1：数组中存入hello

import java.util.Arrays;

 

public class Test6_数组 {

 

       public static void main(String[] args) {

              System.out.println("test...");

              f1();

       }

 

       private static void f1() {

           int[] i = new int[]{1,2,3,4,5};

              System.out.println(Arrays.toString(i));

 

 

              char[] a = new char[5];

              a[0]='h';

              a[1]='e';

              a[2]='l';

              a[3]='l';

              a[4]='o';

              System.out.println(Arrays.toString(a));

       }

      

}

3.4 数组的长度

1. length属性获取数组长度
2. 数组一旦创建，长度不可变
3. 允许0长度的数组

4 数组的遍历
从头到尾，依次访问数组的位置。

4.1 形式

for(int i=0;i<a.length;i++){

   syso(a[i]);

}

4.2 demo1：输出每个月的天数

public class Test9_GetDay{

       public static void main(String[] args){

              int[] days=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};

 

              for(int i=0;i<days.length;i++){

                     System.out.println((i+1)+"月有"+days[i]+"天");

              }

             

       }

}

4.3 demo2：遍历数组，存入1到10

public class Test7_数组遍历 {

       public static void main(String[] args) {

              f1();

       }

 

       private static void f1() {

              int[] arr=new int[10];

              for (int i = 0; i < arr.length; i++) {

                     arr[i]=i+1;

                    

              }

System.out.println(Arrays.toString(arr));

       }

}

4.4 demo3：创建随机数组
获取100以内的随机值的数组

import java.util.Arrays;

import java.util.Random;

 

public class t {

       public static void main(String[] args) {

              f();

       }

 

       private static void f() {

              int[] a = new int[5];

             

              for (int i = 0; i < a.length; i++) {

                     a[i]=1+new Random().nextInt(100);

              }

              System.out.println(Arrays.toString(a));

             

       }

}

5 数组工具类Arrays
5.1 Arrays.toString(数组)

把数组里的数据，用逗号连接成一个字符串。 格式：[10, 14, 20, 46, 51]

5.2 Arrays.sort(数组)

对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。

对引用类型数组，使用优化后的合并排序算法。

5.3 Arrays.copyOf(数组，新的长度)

把数组复制成一个指定长度的新数组。

新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容

新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容

5.4 测试

int[] a = Arrays.copyOf(arr, 10);//数组的复制，大于原来长度相当于扩容

System.out.println(Arrays.toString(a));//[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]

System.out.println(a.length);//10       

int[] a2 = Arrays.copyOf(arr, 3);//数组的复制，晓宇原来长度相当于截取前几个数据

System.out.println(Arrays.toString(a2));//[12, 30, 20]

System.out.println(a2.length);//10

6 二维数组
存放数组的数组，也就是说数组里存的还是数组的数据形式。

6.1 冒泡排序
相邻位置比较，从小到大排序，如果小就往前换。i代表从头到尾遍历循环数据。

import java.util.Arrays;

import java.util.Random;

 

public class TT {

 

       public static void main(String[] args) {

              int[] arr = new int[]{43, 36, 45, 18, 24,9,20,32};

              int[] arrnew = f1(arr);

              System.out.println(Arrays.toString(arrnew));

       }

 

       private static int[] f1(int[] a) {

              //外循环控制循环次数，如果5个数字，循环4次就行

              for (int i = 0; i < a.length-1; i++) {

                     //内循环控制比大小，循环次数和外循环一样

                     for (int j = 0; j < a.length-1; j++) {

                            if(a[j]>a[j+1]){

                                   int t = a[j];

                                   a[j]=a[j+1];

                                   a[j+1]=t;

                            }

                     }

              }

             

              return a;

       }

6.3 还有其他算法
如：合并算法，二分算法，快速算法等，冒泡最常见，后面博客会讲到