Java基础-04-数组

最新推荐文章于 2023-03-06 17:03:17 发布
最新推荐文章于 2023-03-06 17:03:17 发布
阅读量424 收藏 1
点赞数
分类专栏： Java入门 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/faith_yee/article/details/44748113
版权

Java基础

Java编程基础

1、数组（常见问题----静态初始化）

Eg：

int []arr = new int [] {1,3,6,5,4};           //定义了一个名为arr的整数数组，同时初始化
或 int []arr1 = {1,3,6,5,4};                         //定有了一个名为arr1的整数数组，并初始化
或 int []arr2 = new int [3];                        //定义了一个名为arr2的整数数组，并开辟了3个整数空间
System.out.println(arr[2]);                  //调用并输出arr数组。若角标越界，会有错误提示。

2、数组（常见操作----遍历）

数组操作

//获取数组中的元素，通常会用到遍历
for(int x = 0 ; x < 3 ; x++)
{
    System.out.println("arr["+x+"]="+arr[x]);
}
//int []arr = new int [] {1,3,6,5,4};

输出结果：

arr[0]=1
arr[1]=3
arr[2]=6

-

/*
 * 数组中有一个属性可以直接获取到数组元素个数(数组名.length)
 * 使用方式：数组名称.length ; 
 */
//数组中属性length使用方法
for(int x = 0 ; x < arr.length ; x++)
{
    System.out.println("arr["+x+"]="+arr[x]);
}
//int []arr = new int [] {1,3,6,5,4};

输出结果：

arr[1]=3
arr[2]=6
arr[3]=5
arr[4]=4

3、数组（常见操作----获取最值）

给定一个数组{5,1,6,4,2,8,9}

（1）、获取数组中的最大值，以及最小值。

思路：

1、获取最值需要进行比较，每一次比较都会有一个较大的值，因为改值不确定，所以用一个变量temp进行临时存储。
2、让数组中的每一个元素都和这个变量中的值进行比较，如果大于变量中的值，就用该变量记录较大值。
3、当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值。
步骤：
            1、定义变量，初始化为数组中任意一个元素即可。
            2、通过循环语句对数组进行遍历
            3、在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量
            4、需要定义一个功能函数来完成，以便提高复用性。
                        （1）、明确结果：数组中的最大元素int
                        （2）、未知内容：一个数组int []

代码：

class demo21
{

        public static int getMax (int [] arr)
        {
            int max  = arr[0];
            for (int x = 0 ; x < arr.length ; x ++)
            {
                if (arr[x] > max)
                {
                    max = arr[x];

                }
            }
            return max ;
        }

        public static void main(String [] args)
        {
            int [] arr =new int []{5,1,6,4,2,8,9};
            int max = getMax(arr);
            System.out.println("Max = "+max);
        }
}

输出结果： Max = 9

4、数组（排序-----选择排序）

选择排序:内循环结束一次，最值出现在头角标位置上

选择功能函数

class demo21
{
        //选择功能函数
        public static void selectSort(int [] arr)
        {    用双层循环去进行每一轮的元素比较
            for (int x = 0 ; x< arr.length; x++)        //外循环控制比较的轮次数
            {
                for(int y = x + 1 ; y < arr.length ; y++)        //内循环控制的是元素间的比较，
                {
                    if(arr [x] > arr[y])            
                    {
                        int temp = arr[x];
                        arr[x] = arr[y];
                        arr[y] = temp;

                    }
                }
            }
        }

        public static void main(String [] args)
        {
            int [] arr =new int []{3,1,4,2,7,5};        //初始化整数数组并赋值
            //int max = getMax(arr);
            for(int x = 0 ; x < arr.length; x++)        //用循环结构输出原数组
            {
                System.out.println("arr ["+x+"]="+arr[x]);
            }
            System.out.println();
            selectSort(arr);                            //调用选择功能函数selectSort
            for(int x = 0 ; x < arr.length; x++)        //用循环结构输出调用功能函数排序后的数组结果。
            {
                System.out.println("arr ["+x+"]="+arr[x]);
            }
}

输出结果：

arr [0]=3
arr [1]=1
arr [2]=4
arr [3]=2
arr [4]=7
arr [5]=5

arr [0]=1
arr [1]=2
arr [2]=3
arr [3]=4
arr [4]=5
arr [5]=7

5、数组（排序----冒泡排序）

冒泡排序：相邻的两个元素进行比较，如果符合条件则换位。

如图：

第一轮：最值出现了最后位

//功能函数代码：
class demo21
{
        //冒泡排序
        public static void bubbleSort(int [] arr)
        {
            for (int x = 0 ; x < arr.length-1; x++)        //外循环控制比较的轮次数
            {
                for ( int y = 0 ; y < arr.length-x-1 ; y ++)        //内循环控制的是元素间的比较，
                {
                    if(arr[y+1]<arr[y])
                    {
                        int temp;
                        temp = arr[y];
                        arr[y]=arr[y+1] ;
                        arr[y+1] = temp;

                    }
                }
            }
        }
        public static void main(String [] args)
        {
            int [] arr =new int []{3,1,4,2,6};        //初始化整数数组并赋值
            for(int x = 0 ; x < arr.length; x++)        //用循环结构输出原数组
            {
                System.out.println("arr ["+x+"]="+arr[x]);
            }
            System.out.println();
            bubbleSort(arr);                            //调用选择功能函数bubbleSort
            for(int x = 0 ; x < arr.length; x++)        //用循环结构输出调用功能函数排序后的数组结果。
            {
                System.out.println("arr ["+x+"]="+arr[x]);
            }
}

6、数组（排序----位置置换功能抽取）

/*
发现无论什么排序，都需要对满足条件的元素进行位置置换，所以可以把这部分相同的代码提取出来，单独封装成一个函数。
*/
//位置置换功能函数
public static void swap(int []arr, int a , int b)
{
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;

}

7、数组（折半查找）

//定义一个功能函数以获取数组中某元素的角标号
class demo21
{
        //定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么表示该key在数组中不存在
        public static int getIndex(int []arr,int key)
        {
            for(int x = 0; x < arr.length ; x++)
            {
                if(arr[x] == key)
                {
                    return x ;            
                }

            }
            return -1;
        }
        public static void main(String [] args)
        {

            int [] arr =new int []{3,2,1,5,4,2,9};        //初始化整数数组并赋值
            int index = getIndex (arr,3);
            System.out.println("Index="+index);
}

返回结果：Index=0

折半查找法：该查找的方法适合有序的数组。

/*折半查找，提高效率，但必须是有序的数组。*/
代码：
class demo21
{

        public static int halfSearch(int []arr ,int key)                         //功能函数折半查找法
        {
            int max = arr.length-1,min=0,mid = (min+max)/2;             //初始化          
            while(arr[mid]!=key && min <= max)                                  //直到角标找到了该值或角标min>max的时候，退出循环
            {
                if(arr[mid]>key)                                  
                {
                    max = mid - 1;
                    mid = (min+max)/2;
                }
                else if(arr[mid]<key)
                {
                    min = mid +1;
                    mid = (min+max)/2;
                }    

            }
            if(min > max)                //在循环时给min和max进行缩小，如果缩小到min>max时，证明key值不存在数组中，所以返回-1
            {
                return -1;

            }
            else return mid;     //否则返回该值得角标号mid
        }

        public static void main(String [] args)          //主函数调用折半查找法！
        {
            int [] arr = {2,4,5,7,19,32,45};
            int index = halfSearch(arr,45);
            if(index == -1)
            {
                System.out.println("数组中不存在该数");
            }
            else System.out.println("Index="+index);

}

折半查找法的第二种方式

class demo21
{
        public static int halfSearch_2(int []arr ,int key)
        {
            int min = 0 , max = arr.length-1,mid = 0;
            while (arr[mid] != key && min <= max)
            {
                mid = (max + min ) >>1;       //用该方法代替mid = (min+max)/2，效率更高，其他和方法一同理
                if(key > arr[mid])
                {
                    min = mid +1;
                }
                else if (key < arr[mid])
                {
                    max = mid -1;            
                }

            }
            if(min > max)
            {
                return -1;
            }
            else return mid;
        }

        public static void main(String [] args)
        {
            int [] arr = {2,4,5,7,19,32,45};
            int index = halfSearch_2(arr,46);
            System.out.println("Index="+index);
}

结果 Index=-1

一道面试题：在一个有序的数组中，我们想插入一个数，并保持原数组的有序性，我们怎样能得出该数在该数组中的位置。

利用折半查找法 图：

/*十进制转换成二进制*/
代码：
class demo21
{
        public static void toBin(int num)               //功能函数toBin将十进制数转换为二进制
        {
            while (num>0)                                     
            {
                System.out.print(num%2);            //num是十进制数，每次循环除2前都取其值的除2余数值并输出
                num = num /2;

            }
        }
        public static void main(String [] args)
        {
            toBin(6);                        //调用函数
         }
}

输出结果：011 
以上结果是个反向的结果！因为6的二进制的表示形式是110，即以上代码需要改进！

/*改进后的十进制转化成二进制代码，即结果的二进制表现形式是正向的。*/
class demo21
{

        //改进后的toBin
        public static void toBin(int num)
        {
            StringBuffer sb = new StringBuffer(); // 创建一个对象StringBuffer新实体的sb，该实体可以引用对象中的append()功能   
            while ( num>0)
            {
                sb.append(num%2);         //把结果011存储到append队列里
                num = num/2;

            }
            System.out.print(sb.reverse());         //把存储在对象sb里的append队列里的结果反向输出。即输出110
        }
        public static void main(String [] args)
        {
            toBin(6);               //引用函数
         }
}

输出结果：110

/十进制转换成十六进制/

代码：
class demo21
{
        //十进制转换成十六进制
        public static void toHex(int num)
        {
            for(int x = 0;x<8;x++)              //循环8次，目的为了把二进制的每一位（共八位）都提取出来
            {
                int temp = num & 15; //输入的十进制数进行与15（二进制形式1111），目的把二进制的每一位（共八位）都提取出来
                if(temp > 9)  //if-else是考虑到如果temp大于10的输出问题，因为十六进制10~15是用字母表示
                {
                    System.out.print((char)(temp-10+'A'));
                }
                else System.out.print(temp);
                num = num >>>4; //每次循环时对十进制数进制右移四位
            }
        }
        public static void main(String [] args)
        {
            toHex(60);  //调用函数，求60的十六进制
        }
}

输出结果：C3000000

/*查表法十进制转换十六进制*/
class demo21
{
        //改进后的toHex
        public static void toHex(int num)
        {
            char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; //制表：代表到十六进制的字符都存储chs字符数组里
            for(int x = 0 ; x < 8  ; x++)
            {
                int temp = num & 15;         //与完15后的temp就相当于字符数据里的角标号
                System.out.print(chs[temp]);        //利用temp值去调用chs字符数组中的字符元素
                num = num >>> 4;
            }

        }
        public static void main(String [] args)
        {
            toHex(60);
        }
}

输出结果：C3000000

但是无论是上面的/十进制转换成十六进制/还是/查表法十进制转换十六进制/，输出的结果都是一个反向的十六进制结果，如果我们需要正过来呢？可以 通过StringBuffer reverse来完成。但是这个工具我们还没学习，所以可以使用已经学习过的容器数组来存储。

/*改进后的查表法十进制转化成十六进制*/

class demo21
{

        //改进后的toHex
        public static void toHex(int num)
        {
            char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
            char []arr = new char [8];             //该字符数组用来存储计算出来的十六进制字符
            int pos = arr.length;     //该整数用来指示字符存储的位置
            while(num!=0)          //当整数右移四位后等于0，跳出，为了不让0存进arr字符数组内
            {
                int temp = num & 15;
                arr[--pos] = chs[temp];           //把字符从最高位存起，即从arr[7]开始存起
                num = num >>>4 ;

            }
            System.out.println("pos="+pos);          //显示arr存到了哪个位置
            //存储数据的arr数组遍历
            for(int x = pos ; x<arr.length;x++)     //输出字符数组，即十六进制结果
            {
                System.out.print(arr[x]+",");
            }
            public static void main(String [] args)
            {
                toHex(60);          //调用函数
            }
}

输出结果:3,C,

/*查表法：改进后十进制转换成二进制*/
class demo21
{        
        public static void toBin(int num)
        {
            //定义二进制的表
            char[] chs = {'0','1'};
            //定义一个临时存储器
            char [] arr =new char [32];
            //定义一个操作数组的指针
            int pos = arr.length;
            while (num!=0)
            {
                int temp = num&1;
                arr[--pos] = chs[temp];
                num = num >>>1;

            }
            for(int x = pos ; x< arr.length;x++)
            {
                System.out.print(arr[x]);

            }
        }
        public static void main(String [] args)
        {
            toBin(-6);
        }
}

输出结果：11111111111111111111111111111010

进制转化优化

通过十进制转化为（二、八、十六）进制的例子我们可以发现他们之间存在许多重复的代码，我们可以把这些代码进行优化成一个通用的功能函数去转化。

代码：
class demo21
{        /*
            转换函数，num是指输入的十进制整数，base是整数要与的位数，例如二进制要与1，八进制要与7，十六进
            制要与15，而offset是指整数要右移的位数，例如二进制每次要右移1位，八进制每次要右移3位u，十六进制每次要右移4位
            所以
            要求二进制就调用trans(num,1,1);
            要求八进制就调用trans(num,7,3);
            要求十六进制就调用trans(num,15,4);
        */
        public static void trans(int num,int base,int offset)    
        {
            if(num == 0)
            {
                System.out.println(0);        //当输入的数为0是直接输出0并退出函数
                return ;
            }
            char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
            char []arr = new char[32];
            int pos = arr.length;
            while(num != 0)     
            {
                int temp = num % base ;
                arr[--pos] = chs[temp];
                num = num >>> offset;

            }
            for(int x = pos ; x<arr.length;x++)
            {
                System.out.print(arr[x]);
            }
        }
        public static void main(String [] args)
        {
            trans(60,1,1);      //60的二进制
            trans(60,7,3);     //60的八进制
            trans(60,15,4);    //60的十六进制
         }
}

输出结果：

111100
74
3C

8、数组（二维数组）

即数组中的数组。 初始化格式：（代码示例）

int [] arr = new int [3];        //一维数组定义
int [][] arr_2 = new int [3][4];        //二维数组定义：定义了名称为arr_2的二维数组，二维数组中有3个一维数组，每一个数组中有四个元素

如图：

另外一种初始化方法（专业方法）:

int [][] arr = new int [3][];
//若System.out.print(arr[0]);
//输出结果是：null

如图：

如果输入以下代码：

arr[0] = new int [3];
arr[1] = new int [1];
arr[2] = new int [3];
System.out.println(arr.length);       //打印的是二维数组的长度:3
System.out.println(arr[0].length);//3
System.out.println(arr[1].length);//1
System.out.println(arr[2].length);//2

如图：

faith_yee
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础--数组练习2
07-25
Java基础之数组练习2
JAVA入门基础--数组
qq_46079450的博客
02-24 1023
文章目录前言一、JVM内存模型（掌握概念）二、数组定义（重点）1.引入库2.读入数据三、数组定义（重点）总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、JVM内存模型（掌握概念） 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、数组定义（重点） 1.引入库 代码如下（示例）： i
数组--java--动态数组--有序数组--底层
余的日常学习
03-04 1357
数组--java--动态数组--有序数组 数组底层
Java基础-数组的使用
m0_71485750的博客
07-09 417
数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）。我们简单的认识一下数组: 那关于数组我们需要学会什么静态初始化数组: 定义数组的时候直接给数组赋值。静态初始化数组的格式如下: 简化格式: 在内存中的表现如下 注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型。数组元素的访问格式: 数组的长度属性: 那么数组的最大索引值该怎么表示? 其实长度减一就是最大索引值 也可以写成 。 什么类型的数组只能存放什么类型的数据，否则报错。 数组一旦定义出来，程序执行的过程中，长
java入门-数组进阶
ros275229的博客
03-06 1282
朵拉的java实训
Java基础-数组
October_D的博客
04-01 715
1：数组是什么 数组是一个容器，可以用来存储相同数据类型的一组数据。 注意：java的数组，一个数组中只能存储1种数据类型。 特点： 1：数组是有长度的；长度：这个数组可以存储几个值。长度从1开始； 2：数组是有下标的；下标：用来操作存取数组中的值，表示数组中元素的位置。下标从0开始，到长度-1结束 3：数组的最大下标永远比长度小1 2：数组的定义方式 方式一：先创建数组，然后赋值 数据类型[] 数组名 = new 数据类型[数组长度]; 或者 数据类型 数组名[] = new ..
Educoder题目：Java入门 - 数组基础答案解析.md
11-01
Educoder题目：Java入门 - 数组基础答案解析
Java基础语法测试-基础数据类型-注解-数组-inet-反射-oop-Java代码实现
03-09
内容概要：通过带着读者编写Java基础语法测试代码，理解基础数据类型-注解-数组-inet-反射-oop-Java代码实现过程和测试代码 适合人群：初学java语法入门测试代码 能学到什么：①注解、数组、数据类型、inet、method...
Java基础--数组练习1（让你醍醐灌顶！！！）
07-24
Java数组练习1
Java基础--Java数组的认识（通透！！！）
07-23
Java数组的认识（通透！！！）
交通灯管理系统
faith_yee的专栏
03-30 1393
交通灯管理系统 交通灯管理系统详讲 模拟实现十字路口的交通灯管理系统逻辑，具体需求如下： *异步随机生成按照各个路线行驶的车辆。 例如： 由南向而来去往北向的车辆 ---- 直行车辆 由西向而来去往南向的车辆 ---- 右转车辆 由东向而来去往南向的车辆 ---- 左转车辆 ...... *信号灯忽略黄灯，只考虑红灯和绿灯。 *应考虑左转车辆控制信号灯，右转车辆不受信号灯控制。
银行业务调度系统
faith_yee的专栏
03-30 553
银行业务调度系统 银行业务调度系统详解 模拟实现银行业务调度系统逻辑，具体需求如下： *银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。 *有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。 *异步随机生成各种类型的客户，生成各类型用户的概率比例为： *VIP客户 ：普通客户 ：快速客户 = 1
Java基础-03-java流程控制、函数及内存结构
faith_yee的专栏
03-30 545
Java基础 编程基础 1、程序流程控制 （1）、三元运算符 (x>y)?z:m; Eg: y = (x>1)?100:200; //若x>1则把100赋给y,否则把200赋给y三元运算符的特点：可以简化代码，但必须有一个结果。 （2）、选择结构 注意：if和switch都很像，但具体什么场景下，应用哪种语句呢？ 如果判断
Java基础-24-网络编程2
faith_yee的专栏
03-30 524
Java基础-网络编程 网络编程2 1、网络编程（TCP-上传图片） 需求：上传图片 客户端： （1）、服务端点 （2）、读取客户端已有的图片数据。 （3）、通过socket输出流将数据发给服务端 （4）、读取服务端反馈信息。 （5）、关闭资源。 测试代码： import java.io.*; import java.net.*; class PicClient {
Java基础-01-Dos指令及Java环境配置
faith_yee的专栏
03-27 489
计算机基础入门 1.dos软件简单常用指令含义及使用方法。 打开dos软件，下图是dos命令提示符界面。 （1）、dir命令：列出单签目录下的文件和文件夹。如图： 图中含义是，输入cd c:\命令后，我们便切换至c盘的目录下，然后在提示符为c:>下输入dir命令，上图便可以看到输入命令得出得结果可以看出c盘的目录下有5个目录（文件夹），包括alip
Java基础-23-网络编程
faith_yee的专栏
03-30 477
Java基础-网络编程 网络编程1 1、网络编程（概述） 网络编程 *网络模型 *OSI参考模型 *TCP/IP参考模型 *网络通讯要素 *IP地址 *端口号 *传输协议 （1）、找到对方IP （2）、数据要发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识，为了方便称呼这
Java基础-10-异常处理及面向对象练习
faith_yee的专栏
03-30 475
Java基础-面向对象 面向对象进阶（续） 1、面向对象（异常finally） Eg：举一个数据库的例子。 public void method()throws NoException { try { 连接数据库; 数据操作；//有可能会出现异常：throw new SQLException(); } catch(SQLE
Java基础-07-面向对象（续2）
faith_yee的专栏
03-30 472
Java基础-面向对象 面向对象入门（续） 1、面向对象（继承描述） 例如：将学生和工人的共性描述提取出来，单独进行描述，只要让学生和工人与单独描述的这个类有关系，就可以了。 Eg： class Person //Person类，具有基本属性 { int age; String name; } class Student extends Perso
Java基础-05-面向对象
faith_yee的专栏
03-30 462
Java基础-面向对象 面向对象入门 1、面向对象概述 （1）、理解面向对象：一种思考思想。如图： （2）、面向对象的优点： 复杂的事情变简单。（以前：执行 。现在：指挥） 2、面向对象（举例） JAVA----->一切皆对象 3、面向对象（类与对象的关系） （1）、例如：人开门（名词提炼法） 人{ 开门(门){门.开();}
头歌java数组基础
最新发布
04-01
以下是Java数组的基础知识： 1. 声明和创建数组：可以使用以下语法声明和创建数组： ``` 数据类型[] 数组名 = new 数据类型[数组长度]; ``` 例如，声明一个整型数组并分配长度为5的空间： ``` int[] numbers ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值