其他分享
首页 > 其他分享> > day6_自我总结

day6_自我总结

作者：互联网

一、回顾

  1. 方法

    ​ 定义：

    访问修饰符  返回值类型  方法的名称（参数列表）{
	方法体；
	return 返回值；
}

    ​ 调用：

    直接书写方法名，就可以调用
调用语法：方法的名称()
调用方式：赋值调用   打印调用   直接调用

    ​ 注意点：

    定义的注意事项：
	a.方法定义的时候，不能进行相互嵌套
	b.方法没有上下级关系，所有方法都是平级
	c.方法可以相互嵌套调用，甚至可以自己调用自己
调用的注意事项：
	a.方法参数
		形参：形式参数  定义变量  多个形参使用逗号来进行分割
		实参：实际参数  变量赋值  实际的参数要与形参数据类型以及顺序一致
	b.return返回值
		如果方法没有返回值 使用void进行修饰  只能使用return; 来结束方法
		如果方法有返回值  就必须使用return来返回具体的数据
方法重载：在同一类中 方法名相同 参数不同(参数数据类型不同或者是参数的个数不同)与返回值与访问修饰符无关
方法的内存图：所有的方法在执行的时候  都会在栈内存中去开辟空间

  2. 数组

    概念：用于存储一组相同数据类型的数据容器

    数组动态初始化
	语法：数组数据类型 [] 数组名称 = new 数组的数据类型[长度]

数组静态初始化
	语法：数组的数据类型 [] 数组名称 = new 数组的数据类型[]{元素罗列}
	简化：数组的数据类型 [] 数组名称 = {元素罗列}

数组赋值与取值
	赋值：数组的名称[索引]=具体的值
	取值：数组的名字[索引]

jvm内存划分：
	栈  堆  方法区  本地方法区  程序计数器

数组内存图：
	一个数组创建的内存：数组在创建的时候 在内存中开辟的是一块连续的空间
    二个数组创建的内存：不同的数组创建的时候 在内存中开辟不同的空间
    两个数组的引用指向一个堆内存：任意一个引用修改数据  获取的都是修改后的数据

数组异常：空指针异常  数组下标越界异常

二、数组操作

2.1 数组最大值

/**
*需求-分析-代码
*/
public class Test08 {
    public static void main(String[] args) {
        //静态初始化一个数组
        int [] arrays = {10,-1,20,30,6,25};
        System.out.println(showMax(arrays));

    }

    //定义一个方法来求出最大值
    public static  int  showMax(int [] arrays ){
        int max=-1;
        //必须对数组进行飞空验证
        if (arrays !=null && arrays.length >0) {
            //获取初始化
               max=arrays[0];
              //使用循环来依次进行比较
            for (int i=0;i<arrays.length;i++) {
                if (arrays [i] > max) {
                    //将值进行替换
                    max = arrays[i];
                }
            }
        }

        return max;

    }
}

2.2 置换数组中的元素

/**
*需求-分析-代码
*/

/* 需求将数组中元素进行置换  置换的规则: 第一个元素  与最后一个元素   第二个元素  与倒着第二个元素进行置换 ....  */

import java.util.Arrays;

public class Test09 {
    public static void main(String[] args) {
        //定义一个数组
//        int [] arrays ={10,20,30,40,50};
//        int [] arr  =showInfo(arrays);
        int []arr = showInfo(new int [] {10,20,30,40,50});
        //toString() 将数组以字符串的格式来显示
        System.out.println(Arrays.toString(arr));

    }

    /**
     *
     * @param arrays 数组
     * @return 置换后的数组
     */
    public  static   int [] showInfo(int [] arrays){
        //对数组进行非空验证
        if (arrays !=null && arrays.length >0) {
            //使用循环遍历
            for (int  i =0;i<arrays.length/2;i++) {
                //定义一个中间变量 来进行值的交换
                int  temp = arrays[i];
                arrays[i]= arrays[arrays.length-1-i];
                arrays[arrays.length-1-i]= temp;

            }

        }
        return  arrays;
    }
}

2.3 查找指定元素在数组指定区间的索引值

step01 需求-分析

A.定义一个方法
  访问修饰符 public  static 
  返回值类型  int 
  参数 :数组 元素  开始索引 结束索引
  方法体:
     使用循环查找这个元素   并且返回索引值

step02 代码

public class Test10 {
    public static void main(String[] args) {
        System.out.println(getIndex(new int[]{10, 20, 30, 40, 50}, 200, 0, 2));

    }

    public static  int  getIndex(int [] arrays, int  num,int startIndex,int endIndex){
        //对数组进行非空验证
        if (arrays !=null && arrays.length >0) {
            //对开始的索引与结束索引需要处理
            //&& startIndex <arrays.length
            if (startIndex  >=0   && endIndex >=startIndex && endIndex <arrays.length){
                for (int  i =startIndex;i<=endIndex;i++) {
                    //使用if来判断是否有此元素
                    if (num == arrays[i]) {
                        //返回索引
                        return  i;

                    }
                }

            }

        }
        //如果返回值是-1  表示没有查找到此元素
        return  -1;

    }
}

2.4 生成扑克牌

step02 分析

A.定义两个数组 
   一个数组是花色
   一个数组是点数
B.使用嵌套for循环来获取数组中的花色与点数

step03 代码

public class Test11 {
    public static void main(String[] args) {
        //定义一个数组
        String [] color ={"♦","♣","♥","♠"};
        //定义一个数组 表示点数
        String [] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        //使用双重for循环来遍历
        for (int i=0;i<color.length;i++) {
            for (int j=0;j<nums.length;j++) {
                //定义一个字符串拼接
                String s =color[i]+nums[j];
                System.out.print(s+"\t");
            }
            System.out.println("");
        }
    }
}

2.5 在数组的指定位置插入元素

step01 需求

数组元素  1    3    5    60   90  null(默认值)
向数组中插入一个值为35 
数组元素  1    3    5    35    60   90  按照升序进行排序

step02 分析

step03 代码

import java.util.Arrays;
import java.util.Scanner;

public class Test13 {
    public static void main(String[] args) {
        Scanner input  = new Scanner(System.in);
        //动态初始化一个数组
        int [] arrays = new int[6];
        //给数组赋值
        arrays[0]=1;
        arrays[1]=3;
        arrays[2]=5;
        arrays[3]=60;
        arrays[4]=200;

        //定义一个变量来记录其索引值
        int index =-1;
        System.out.println("请输入要插入的数据");
        int num = input.nextInt();
        //使用循环来查找第一个比插入值大的索引值
        for (int i=0;i<arrays.length;i++) {
            //使用if选择节奏判断
            if (arrays[i] >num) {
                index = i;
                //结束循环
                break;
            }
        }
       if (index ==-1){
            index =  arrays.length-1;

       }else {
           //将数组中元素进行移动
           for (int  j=arrays.length-1;j>index;j--) {
               arrays[j] =arrays[j-1];
           }
       }

        //进行值的插入
        arrays[index] = num;
        //打印输出数组中元素
        System.out.println(Arrays.toString(arrays));
    }
}

三、冒泡排序

import java.util.Arrays;

public class Test12 {
    public static void main(String[] args) {
        //定义一个数组
        int [] arrays = {20,10,-1,70,15};
        //第一个for循环 控制比较的轮数
        for (int i=0;i<arrays.length-1;i++) {
            //第二个for循环控制比较次数
            for (int j=0;j<arrays.length-1-i;j++) {
                //前面两个元素进行比较
                if (arrays[j] > arrays [j+1]) {
                    //进行值的交换
                    int  temp = arrays[j];
                    arrays[j] =arrays[j+1];
                    arrays[j+1] = temp;
                }
            }
        }

        System.out.println(Arrays.toString(arrays));
    }
}

标签：总结,day6,元素,自我,int,static,数组,arrays,public
来源： https://www.cnblogs.com/zhenglyz/p/16491987.html