[其他交流] ”数组“笔记提交专用帖

dcw2015 · dcw2015

:dizzy:忘记给同学名字打马赛克了。。。还有代码回贴要怎么弄出表格来啊。求告知

夕阳醉 · 夕阳醉

本帖最后由夕阳醉于 2015-6-9 01:03 编辑

笔记内容：数组
笔记来源：毕向东Java基础视频第四天
正文：

本来打算放不少东西的，发现放不下，经过N此编辑。折半查找也没弄进来。郁闷~~~

1.数组的定义

/*
1.数组的定义
2.获取数组元素里的长度的方法：arr.length
*/
class ArrayDemo
{
public static void main(String[] args)
{
int[] arr=new int[3];
System.out.println(arr[0]);
//获取数组中的元素，通常会用到遍历，也就是循环
int[] arr={1,3,5,2,6,7};
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print("arr["+x+"]="+arr[x]+",");
else
System.out.print("arr["+x+"]="+arr[x]);
}
}

复制代码

2、本来打算把选择排序，位置置换也放进来，但发现好像是不够。老出现错误。所以就选择了一个冒泡排序举例。

/*
冒泡排序(相邻两个元素进行比较)第一圈最值在最右边,y也就是说第二圈不需要使用。以此类推
思路：1.大圈套小圈，循环嵌套。
2.判断大小，定义一个变量记住需要的值，if
定义功能：
1.明确运算结果：无，void
2.明确未知内容：有，int[]
*/
class BubbleSort
{
public static void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=0;y<arr.length-x-1;y++)//-x意思是比较范围缩小，-1意思是角标不越界。
{
if (arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
public static void getArray(int[] arr)
{
System.out.print("[");
for (int x=0;x<arr.length ;x++ )
{
if(x!=arr.length-1)//为了格式更加方便阅读
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr=new int[]{3,2,5,9,7,6,4};
getArray(arr);//排序前
bubbleSort(arr);//排序
getArray(arr); //排序后
}
}

复制代码

3、查表法

/*
用查表法将十进制转换成十六进制。
思路：
1.先定义一个数组，这样就可以通过查找对应的角标找到对应的值。类型为char[] ch={....};
2,获取最低4位：&15，用变量记录：int temp=;
3.右移4位，再&15，得到下一个结果。
发现运行完结果是反向的，把它变成顺序的。用定义一个临时数组来存储这些数据，在通过遍历来查看。
思路：1.定义数组：char[] 2.进行遍历，for
*/
class ArrayChaBiao
{
public static void toHex(int num)
{
char[] ch={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] ch1=new char[8];//定义临时存储容器
int pos=ch1.length;//定义指针
while (num!=0)
{
int temp=num&15;
ch1[--pos]=ch[temp];
//System.out.println(ch[temp]);
num=num>>4;
}
for(int x=pos;x<ch1.length;x++)
{
System.out.print(ch1[x]+",");
}
}
public static void main(String[] args)
{
toHex(60);
}
}

复制代码

4、二维数组

/*
二维数组的定义及应用
定义：int[][] arr=new int[][];或者int[] y[]=new int[][];
定义一个二位数组，并且求二维数组的和。
思路：1、大圈套小圈，嵌套；
2。累加思想。定义sum
*/
class TwoArray
{
public static void main(String[] args)
{
/*
//int[] arr[]=new int[4][5];//二维数组：有4个一维数组，每个一维数组里5个元素。
int[][] arr-new int[4][];//4个一维数组。一维数组的元素个数不确定
arr[0]=new int[2];
arr[1]=new int[5];
arr[2]=new int[3];
arr[3]=new int[4];
//二位数组里一维数组的元素个数。
arr[1][3]=10;//表示arr[1]中一维数组中第三个元素arr[3]的值为10；
arr[3][4]=33;//表示arr[3]中一维数组中第4个元素arr[4]的值，但是越界了，error；
* /
int sum=0;
int[][] arr={{2,3,1,6,2,7,4},{3,2,1,6},{3,6,7,1,3,2}};
for (int x=0;x<arr.length ;x++ )
{
for(int y=0;y<arr[x].length;y++)
{
sum=sum+arr[x][y];
}
}
System.out.println(sum);
}
}

复制代码

张沐风 · 张沐风

笔记内容：数组
笔记来源：毕向东Java基础视频第第三天的最后一个加上第四天的所有视频：
正文：
首先是对一个数组来说，就是数组的定义，那么何为数组，用通俗的话来说就是可以存放数据的一个容器。但是从专业的术语来讲就是有限制了，数组：同一个类型的数据集合。那么我们为什么要用数组，因为数组中的元素好操作，数组中的元素从0开始编号。接下来就是要定义一个数组
数组有2种定义形式：1.元素类型[ ]  数组名 = new 元素类型（元素的个数或者数组的长度）；
                           2.元素类型[ ]  数组名 = new 元素类型[ ]{元素，元素，...... }；
可以用int 型举一个例子：如下分别用两种形式来定义一个数组
1.  int[ ] arr = new int[ 3 ];
2.  int[ ] arr = new int[ ]{1,2,3,4,5};
   int[ ] arr = {1,2,3,4,5};
接下来就是对数组进行遍历，就是得出数组中的每个元素的值。

// 数组的遍历
class Day3_9
{
public static void main(String[] args)
{
//int[] a = new int[]{1,2,4};
int a[] = {1,2,4};
for (int b = 0;b<3;b++ )
{
System.out.println(a[b]);
}
}
}

复制代码

这时候有一个小细节，就是数组在输出过程中，角标可能出现越界的状况，应该注意数组的第一个元素的角标是从0开始的，而不是1。因为上面的代码是第一次写，所以说元素比较少，但是在现实的项目中，可能会出现很多元素的情况，我们又不可能一一的去数元素的个数，所以面临循环的时候，我们可以把数组的长度写成arr.length。而不再去通过人来数。
因为数组的for循环我不想写在主函数中，所以我们把它封装成一个函数，为了下次更好的调用。

//数组的遍历和把最后一个数的，去掉用length、来表示；
class Day4_1
{
public static void main(String[] args)
{
int[] a ={1,4,55,4,7,4546};
printArray(a);
}
public static void printArray(int[] arr)
{
for (int a = 0;a<arr.length ;a++ )
{
if (a!=arr.length-1)
System.out.print(arr[a]+", ");
else
System.out.print(arr[a]);
}
}
}

复制代码

OK，那么问题来了，在实际操作中，我们用数组的目的不是为了仅仅遍历其中的元素，而是要的到数组中的某个具体的元素，好比最大值，最小值之类的。那么我们就拿数组的最大值和最小值以及一次都求出来来做演示，因为代码都是自己手写的，所以有些不规范的地方大家见谅。因为个人比较闲麻烦，所以每次我都把要操作的定义成了一个函数。代码如下：

//算数组中的最大值和最小值
class Day4_2
{
public static void main(String[] args)
{
int a[] = new int[]{1,5,6546,7,987,45};
maxArray(a);
minArray(a);
stepOne(a);
}
public static void maxArray(int arr[])
{
int max = arr[0];
for (int a = 0;a<arr.length ;a++ )
{
if(max < arr[a])
max = arr[a];
}
System.out.println("数组中的最大数是："+max);
}
public static void minArray(int []arr)
{
int min = arr[0];
for (int a = 0; a<arr.length;a++ )
{
if (min>arr[a])
min =arr[a];
}
System.out.println("数组中的最小数是："+min);
}
public static void stepOne(int arr[])
{
System.out.println("----------------------");
int max = arr[0];
int min = arr[0];
for (int a = 0;a<arr.length ;a++ )
{
if(max < arr[a])
max = arr[a];
}
System.out.println("数组中的最大数是："+max);
for (int a = 0; a<arr.length;a++ )
{
if (min>arr[a])
min =arr[a];
}
System.out.println("数组中的最小数是："+min);
}
}

复制代码

好了，求完了数组的最大值和最小值，那么问题来了，我想给数组中的元素排个序，我觉得不排序看着闹心，所以我们就要把数组给整理一下然后输出来，就拿最简单的顺序排序和冒泡来举个例子。（ps：对于这两个排序算法，我就不想一一解释了，以为大学里的数据结构和算法没有学好，所以大家要想知道这两个排序是怎么进行的，还是去看一下数据结构，以及栈内存和堆内存的介绍，反正排序的算法有好多。java的util包中也会给你，我好像说多了）
先来顺序

//给数组进行排序顺序排序
class Day4_3
{
public static void main(String[] args)
{
int a[] = new int[]{1,2,45,4,1,556,46564,787,1,1,45,4,5,2,2,24};
printArray(a);
sortArray(a);
printArray(a);
}
//排序：两个数比较从以一个数开始每一个都与后面的进行比较与后面最小的的交换位置
public static void sortArray(int[] arr)
{
for (int a = 0;a<arr.length ;a++ )//双重循环就相当于每一次都进行一行的对比，先把一地个
{
for (int b = a;b<arr.length ;b++ )
{
int temp;
if(arr[a]>arr[b])
{
temp = arr[b];//定义一个临时变量对两个值进行交换
arr[b] = arr[a];
arr[a] = temp;
}
}
}
}
public static void printArray(int[] arr)
{
for (int a = 0;a<arr.length ;a++ )
{
if (a!=arr.length-1)
System.out.print(arr[a]+", ");
else
System.out.print(arr[a]);
}
}
}

复制代码

再来个冒泡吧：

import java.util.*;//引用包的形式
//冒泡排序相邻两个元素进行比较
class Day4_4
{
public static void main(String[] args)
{
int a[] = new int[]{45,46,7,578,9,1,245};
//bubbleArray(a);
//printArray(a);
Arrays.sort(a);// 系统已经定义好了的固定语句，好坑啊。shit
printArray(a);
}
public static void bubbleArray(int arr[])
{
for (int x = 0;x<arr.length-1 ;x++ )
{
for (int y = 0;y<arr.length-x-1 ; y++)
{
if(arr[y]>arr[y+1])
{
int temp;
temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void printArray(int[] arr)
{
for (int a = 0;a<arr.length ;a++ )
{
if (a!=arr.length-1)
System.out.print(arr[a]+", ");
else
System.out.print(arr[a]);
}
}
}

复制代码

这里简要说明一下，java的自带util包中已经有可以直接进行排序的算法了，但是前面学习，还是中规中矩的来。

前面我们都是进行一维数组的演示，那么问题来了，我想操作二维数组，用通俗语言来讲，二维数组就是数组中的数组，好吧，首先是定义一个二维数组
1.int arr[ ][ ] = new int[ 元素的个数][元素的个数 ];
2.int arr[ ][ ] = new int[ ][ ]{{, , , },{ , },{, , }.....};
既然定义了我们就要遍历同样的招式我就不演示了，直接求二维数组中所有元素的最小值，那么最大值也同理

// 定义一个二维int数组，编写代码获取最小元素。
class Test3
{
public static void main(String[] args)
{
int arr[][] = new int[][]{{5,8,89,7,6,-1},{40},{3,7,889},{45,7,3}};
int min = arr[0][0];
for (int x = 0;x<arr.length ;x++ )
{
for (int y = 0;y<arr[x].length ; y++)
{
if(min > arr[x][y])
min = arr[x][y];
}
}
System.out.println("用户定义的二维数组中的最小值是："+min);
}
}

复制代码

好的，总之用毕老师的一句话来说（面向对象的话来说），数组就是更方便的对元素进行操作和整理，以及调用。

温暖的小白 · 110414072

本帖最后由 110414072 于 2015-6-11 01:14 编辑

笔记内容：数组
笔记来源：毕向东Java基础视频第4天
正文：

*****************************************************************************************************************

数组的概念：
            同一种类型数据的集合。
      好处：
            可以自动给数组中的元素从0开始编号，方便操作这些元素。
数组的定义格式：
      格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度]
            示例：int[] arr = new int[5]
      格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素, ....}
            示例：int[] arr = new int[]{3,5,6,7,2}
                        int[] arr = {3,5,6,7,2}
            注意：数据在明确的时候可以用这种创建方式

int[] arr = new int[3]
System.out.println(arr[3]);

复制代码

编译时不会报错，运行时回报ArrayIndexoutofBoundsException角标越界异常
如何发生的？数组中没有这个元素，而这个元素超出数组范围。

arr = null;
System.out.println(arr[1]);

复制代码

编译不会报错，运行回报NullPointerException空指针异常
      如何发生的？当引用没有任何指向的值null，该引用还用于操作实体
数组的操作：
      获取数组中的元素：通常会用到遍历，一般的数组遍历用到的是for循环
      数组：arr[x]的长度是arr.length-1，x是数组的角标，也称索引
      数组中有一个属性可以直接获取到元素个数或长度：数组名.length

/*
* 数组常见操作之一：获取最值
* 给定一个数组，获取最大值，最小值
*
* 思路：
* 1、获取最值，需要相邻元素进行比较，比较后用临时变量存储较大值
* 2、让数组中每个元素都和这个临时变量进行比较
* 3、当所有元素比较结束后，该变量就是元素的最大值
*
*/
public class TestDemo {
public static int getMax(int[] arr) {
// 定义临时最值
int max = arr[0];
// 遍历数组
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 返回最大值
return max;
}
public static void main(String[] args) {
int[] arr = { 12, 24, 54, 65, 32, 33, 98 };
int max = getMax(arr);
System.out.println("Max:" + max);
}
}

复制代码

/*
* 对数组进行排序
*/
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
// 用临时遍历接收大的值，依次交换位置，这样最后一位就是最大值
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}

复制代码

/*
* 冒泡排序
*/
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// arr.length-i就是让每一次比较的元素减少，减1就是防止角标越界
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

复制代码

从大到小,交换if判断的条件

arr[j+1]>arr[j]

复制代码

ITClody · ITClody

回帖格式：
 笔记内容：数组
 笔记来源：毕向东Java基础视频第4天
 正文：
 4、数组的基本概念以及分类
 1）基本概念：
 在程序设计中，为了数据处理方便，我们把具有相同类型的若干变量按照有序的形式组织起来，这些按序排列的同类数据元素的集合称为数组。
 在 C 语言中,数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本类型或者是构造类型。
 2）数组的几个名词：
 什么是数组：一组具有相同数据类型的数据的有序集合。
 数组元素：构成数组的数据。数组中的每一个数组元素具有相同的名称，不同的下标，可以作为单个变量使用，所以也称为下标变量。
 数组的下标：就是数组元素的位置的一个索引或指示。
 数组的维数：就是数组下标的个数。数据数组的维数可以将数组分为一维数组、二维数组、三维数组、多维数组。

 按存储的内容分类：按数组元素的类型不同，数组又分为：
 数值数组：用来存储数组
 字符数组：用来存储字符
 指针数组：用来存放指针（地址）
 结构数组：用来存放一个结构体类型的数据
 按照维度分类：
 一维数组：
 二维数组：
 三维数组：
 多维数组：

5、数组元素作为函数参数
 1）数组可以作为函数的参数使用，进行数据的传递。
 a、一种是把数组元素（下标变量）作为实参使用；
 数组元素就是下标变量，它与普通变量并没有区别。因此它作为函数实参使用与普通变量时完全相同的，在发生函数调用时，把作为实参的数组元素的值传递给形参，实现单向的值传递。
 b、一种是把数组名作为函数的形参和实参使用。

6、一维数组的定义以及注意事项
 1）一维数组的介绍：
 如果一个数组的所有元素都是基本数据类型，那么该数组称为一维数组
 2）一维数组的定义
 在C语言中使用数组必须先进行定义。一维数组的定义方式：
 类型说明符 数组名[常量表达式]
 a、类型说明符：是任一种基本数据类型或构造数据类型。
 b、数组名：用户定义的数组标示符。
 c、方括号中的常量表达式：表示数据元素的个数，也称为数组的长度。
 例如：int a[10]; //定义整形数组a，有10个元素
 float b[10],c[20]; //定义实型数组b，有10个元素，定义实型数组c，有20个元素。

注意：a、数组的长度可以是一个常量，也可以是常量表达式。
 b、数组的命名规则：严格按照标示符的命名规范。
 c、数组名称不能和其他变量同名。
 d、数组的长度不可以为一个变量（C99标准要求的）
 e、数组的长度可以使用宏定义（#define M 5 int a[M] -->此时M是一个宏定义）
 f、定义数组的时候，还可以定义普通变量。（如：int x,y,z[9];）
 3)一维数组的初始化：
 数组初始化赋值是指在数组定义时给数组赋予初值。数组初始化是在编译阶段进行的。这将减少运行时间，提高效率。
 初始化方式有两种：
 a、定义的同时初始化
 例如：
 类型说明符数组名[常量表达式]={值1，值2，值3...值n};
 实例：int a[3]={1,4,2}; //长度由[]中的值决定的
 int b[]={2,5,7,6}; //长度是由{}中的值的个数决定的
 int c[10]={[3]=23,[8]=34};//定义长度为10的数组，下标为3的元素的值为23，下标为8的数组元素为34
 b、先定义、后初始化
 类型说明符数组名[常量表达式];
 数组名[0]=值;
 数组名[1]=值;
 数组名[2]=值;
 实例：int d[10];
 d[0]=1;//为下标为0的数组元素赋值为1；即数组的第一个元素值为1；
 d[1]=2;//为下标为1的数组元素赋值为2；即数组的第二个元素值为2；
 d[2]=3;//为下标为2的数组元素赋值为3；即数组的第三个元素值为3；
 ...
 d[9]=100;//为下标为9的数组元素赋值为100；即数组的第十个元素值为100；
 4）一维数组中让人疑惑的问题：
 数组如果没有初始化，数组中到底有没有值？如果有，值是多少？如果数组部分进行了初始化，那么没有初始化的那些元素有没有值，如果有，值是多少？
 a、数组如果没有初始化，数组中的元素是有值的。值是垃圾值。
 b、如果数组部分进行了初始化，那么没有初始化的那些元素有值，如果有，值是0。
 c、如果是字符数组进行了部分初始化，那么没有初始化的部分也有值，值为ASCII码对应的默认值。

 5）一维数组的引用方式
 数组元素是组成数组的基本单元。数组元素也是一种变量，其标识方式是数组名后跟一个下标。下标表示了元素在数组中的顺序号。
 特别强调：使用先定义后初始化的方式，如果部分数组元素被初始化了，系统不会对没有初始化的那部分元素进行赋值0的操作。

 6）一维数组的存储方式
 存储方式：
 a、计算机会给数组分配一块连续的存储空间；
 b、数组名代表数组的首地址，从首地址位置，依次存入数组的第一个、第二个、...、第n个元素；
 c、每个元素占用相同的字节数（取决于数据类型）
 d、并且元素之间的地址是连续的。

 7）一维数组的地址
 一维数组的地址：
 a、数组内部的元素地址是连续的；
 b、数组名存放的是数组的首地址-->数组的首地址：数组的第一个元素首地址（第一个元素的第一个字节的地址）
 c、补充：数组名==&数组名[0]; 数组名是一个常量 存储的就是数组的首地址
 d、数组的每个元素的地址

 8）一维数组长度计算方法
 a、因为数组在内存中占用的字符数取决于其存储的数据类型和数据个数
 b、数组在内存中占用的总字节数：sizeof(数组名);
 c、计算数组长度的方法：
 数组的长度=数组占用的总字节数/数组元素占用的字节数
例如：int a[]={1,5,3,2,7,4,9,23,46,47,36};
 int a_len=sizeof(a)/sizeof(int);

 9）一维数组的越界问题
 数组下标越界是不安全的，因为这个空间不属于你。可能会有数据丢失现象发生。

 10）应用：找最大值
 //通过for循环，从键盘获取10个数，存放到数组中。找出10个数中的最大值
 void main(){
int a[10];
//循环接收用户输入
for(int i=0;i<10;i++){
printf("请输入第%d个数\n",i+1);
//接收数据，保存到数组中
scanf("%d",&a[i]]);
}
//遍历数组，输出看看输入的10个值
for(int i=0;i<10;i++){
printf("%d\t",a[i]);
}

//找出最大值
int max=a[0];
for(int i=0;i<10;i++){
if(max<a[i]){
max=a[i];
}
}
printf("输入的最大值为：%d\n",max);
 }

 11）数组名作为函数参数
 a、用数组元素作为函数参数不要求形参也必须是数组元素，但是用数组名作为函数参数时，则要求形参和相对应的实参都必须是类型相同的数组。
 b、在C语言中，数组名除作为变量的标示符之外，数组名还代表了该数组在内存中的起始地址，因此，当数组名作为函数参数时，实参与形参之间不是“值传递”，而是“地址传递”，实参数组名将该数组的起始地址传递给形参数组，两个数组共享一段内存单元，编译系统不再为形参数组分配存储单元。
 c、在变量作为函数参数时，所进行的值传递是单向的。即只能从实参传向形参，不能从形参传回实参。形参的初值和实参相同，而形参的值发生改变后，实参并不变化，两者的终值是不同的。

 12）数组名作为函数参数的注意点
 a、形参数组和实参数组的类型必须一致，否则将引起错误；
 b、形参数组和实参数组的长度可以不相同，因为在调用时，只传送首地址而不检查形参数组的长度。当形参数组的长度与实参数组不一致时，虽然不至于出现语法错误（编译能通过），但程序执行结果将与实际不符，这是应该注意的。
 c、在函数形参表中，允许不给出形参的长度，或用一个变量来表示数组元素的个数。例如，可以写为：
 void nzp(int a[]) 或者写为： void nzp(int a[],int n)
 其中行参数组a没有给出长度，而由n值动态地表示数组的长度。n的值由主调函数的实参进行传递。
 d、多维数组也可以作为函数的参数。在函数定义时对行参数组可以指定每一维的长度，也可以省去第一维的长度。因此，下面写法都是合法的：
 int MA(int a[3][10]) 或者： int MA(int a[][10])

 13)数组名作为函数参数的注意点
 a、C语言中规定，不管是什么类型的数据，数据的内存地址在内存中占用8个字节

wushenshen5180 · wushenshen5180

笔记内容：数组
      笔记来源：毕向东Java基础视频第4天
      正文：
(都是自己理解的，如果有错误，请包涵，代码都是看了视频自己写的)
         数组:使用来存储数据的集合或容器或者存储同一数据类型的集合或容器。

      格式：创建数组有两种格式
1.类型[] 数组名 = new 类型[]{元素，元素，...};
2.类型[] 数组名 = {元素，元素，...};

//选择排序和冒泡排序

class SortDemo
{
public static void main(String[] args)
{
//两种方式定义数组
int[] arr = {18,69,12,186,74,13,10};
int[] arr1 = new int[]{123,234,435,12,34,89,128};
//主函数的输出语句,以字符串形式输出排序前后的数组
//在这里输出arr为例
//排序前的顺序
System.out.println("输出前");
String a = showArr(arr);
System.out.println(a);
System.out.println("--------------------------------------");
//排序后的顺序
System.out.println("输出后");
selectionSort(arr); //选择排序
a = showArr(arr);
System.out.println(a);
bubbleSort(arr);//冒泡排序
a = showArr(arr);
System.out.println(a);
}
//数组的遍历
public static String showArr(int[] arr)
{
String a = "";
//遍历数组，将数组元素用字符串连接
for(int x=0;x < arr.length;x++)
{
if (x!=arr.length-1)
a = a + arr[x] + "，";
else
a = a + arr[x];
}
return a;
}
//选择排序
public static void selectionSort(int[] arr)
{
//for外循环控制主动比较的数组项
for(int x=0;x<=arr.length-2;x++)
{
//for内循环控制被比较的数组项
for(int y=x+1;y<=arr.length-1;y++)
{
//判断，如果比较的数据项大于比较的数据项，则交换
if (arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
//冒泡排序
/*
冒泡排序原理理解：从第一个元素开始，每个数组元素都与自己下一个元素比较大小，
如果大于后一个元素，就交换位置，如果不大于，就位置不变，一轮过后
最后一个元素则为最大元素。每轮比较过后，下轮比较就不包括已确认大
小的元素。最后经过 (arr.length-1)次比较，排序完成。
*/
public static void bubbleSort(int[] arr)
{
//确认每轮比较参与的元素（去掉了上一轮中确认最大的元素）
for (int x = (arr.length-1); x>0 ;x--)
{
//从0角标的数组元素开始，每一个元素都与下一个元素比较
//大的往后,这样一轮过后，最后一个元素就是最大的了
for (int y = 0;y < (arr.length-1);y++)
{
if (arr[y] > arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}
public static void swap(int[] arr,int index1,int index2)
{
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
}

复制代码

//数组的线性查找和二分查找

class ArrSearch
{
public static void main(String[] args)
{
int[] arr = new int[] {10,19,21,45,63,84,96};
int key = 21;
int a = linearSearch(arr,key);//线性查找
int a1 = halfSearch(arr,key);//二分查找法
System.out.println("线性查找后匹配的数组元素下标是："+a);
System.out.println("二分查找后匹配的数组元素下标是："+a1);
}
/*
线性查找：就是遍历整个数组，将数组中每个元素都与
key值校队，匹配成功后将匹配的数组元素的下标返回
如果遍历整个数组没有匹配元素，就返回-1.
*/
public static int linearSearch(int[] arr,int key)
{
for (int x=0; x<arr.length-1; x++)
{
if (key == arr[x])
{
return x;
}
}
return -1;
}
/*
二分查找法：使用此查找该方法的前提是数组是有序的
方法的思想就是让Key与数组的中间元素相比较：
1.比中间元素大，则查找的范围就变成数组的后一半元素；
2.比中间元素小，则查找的范围就变成数组的前一半元素；
3.跟中间元素匹配。
*/
public static int halfSearch(int[] arr,int key)
{
int min = 0;
int max = arr.length-1;
int mid = (min+max)/2;
while (key != arr[mid])
{
if (key>arr[mid])
{
min = mid + 1; //因为中间元素已经比较过，所以后移一位
}
else if(key<arr[mid])
{
max = mid - 1; //因为中间元素已经比较过，所以前移一位
}
//判断如果没有匹配的情况下，二分最后导致min>max
if (min>max)
{
return -1;
}
//每一轮mid值都会随min和max改变
mid = (mid+max)/2;
}
return mid;
}
}

复制代码

//二维数组
   创建：数据类型[][] 数组名；
   创建二位数组必须明确有多少一维数组；
   二维数组相当于二位数组里的元素是一维数组。
//二维数组求和

class TwoArry
{
public static void main(String[] args)
{
int[][] arr = {{12,13,14},{48,93,109},{23,10,18,95}};
int sum = 0;
for (int x=0; x<arr.length; x++)
{
for (int y=0; y<arr[x].length; y++)
{
sum += arr[x][y];
}
}
System.out.println(sum);
}
}

复制代码

qq2403956244 · qq2403956244

笔记内容：数组
笔记来源：毕向东Java基础视频第4天
正文：
楼上++，基本知识已回复，在这补充——————>一维数组“希尔排序”和二维数组“杨辉三角”。
1.【希尔排序】

/*
【希尔排序】
思路：
a.把一组数据按下标的一定增量分组，对每组使用直接插入排序。
b.增量=数组长度/2，在循环的过程中增量每次/2直到增量=1,
即所分组的数据在一组中为止。
*/
class ArrayShellSort
{
public static void shellSort(int[] array)
{
for(int d=array.length/2; d>=1; d=d/2) //d=5
{
for(int x=d; x<array.length; x++)
{
int y;
int temp = array[x];
for(y=x-d;y>=0&&array[y]>temp; y-=d) //直接插入排序
{
array[y+d] = array[y];
}
array[y+d] = temp;
}
//printArray(array);
//System.out.println();
}
}
public static void printArray(int[] array)
{
for(int i=0; i<array.length; i++)
{
if(i!=array.length-1)
{
System.out.print(array[i]+",");
}
else
{
System.out.print(array[i]);
}
}
}
public static void main(String[] args)
{
int[] array ={2,8,12,4,17,9,7,6,10,3,1};
// 0 1 2 3 4 5 6 7 8 9 10 角标
shellSort(array);
printArray(array);
}
}

复制代码

qq2403956244 · qq2403956244

本帖最后由 qq2403956244 于 2015-6-21 00:01 编辑

2.【杨辉三角】

/*
二位数组的应用：【杨辉三角】
1 * * * * * 1
1 1 * * * * 1 1
1 2 1 ————> * * * 1 2 1
1 3 3 1 * * 1 3 3 1
1 4 6 4 1 * 1 4 6 4 1
1 5 10 10 5 1 1 5 10 10 5 1
思路：
a.定义一个二维数组存储需要打印的元素。
b.固定每一行第一个数值为1，后面紧接着的数值为上一行的两个数值的和，
然后赋给该行数值在数组中的位置，最后打印数组中的值。
如：上一行： 1 1 0
该行： 1 1+1 1+0 ————>数组初始化为0
*/
class YangHuiSanJiao
{
public static void sanJiao(int n)
{
int[][] array = new int[n][n];
for(int x=0; x<array.length; x++)//行数
{
for(int y=x; y<array.length-1; y++)
{
System.out.print(" ");
}
for(int z=0; z<=x; z++)
{
if(z==0)
{
array[x][z] = 1; //每一行第一个值
System.out.print(array[x][z]+" ");
}
else
{
array[x][z] = array[x-1][z-1]+array[x-1][z];
System.out.print(array[x][z]+" ");
}
}
System.out.println(); //打印一行后换2行
System.out.println();
}
}
public static void main(String[] args)
{
sanJiao(7); //打印7行
}
}

复制代码

温暖的小白 · 13820056923

本帖最后由 13820056923 于 2015-6-21 22:49 编辑

笔记内容：数组
笔记来源：毕向东Java基础视频第4天和教材
正文：
1.数组的定义：
在Java中可以使用以下格式来定义一个数组：int[] x=new int[100]。
相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。
也可以将代码分成两句来写：int[] x; x=new int[100]; 第一行代码int[] x声明了变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。第二行代码x=new int[100],创建了一个数组，将数组的地址赋值给变量x。这时内存中的状态会发生变化。

当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。

数组的静态初始化有两种方式，类型[] 数组名=new 类型[]{元素，元素，......};类型[] 数组名={元素，元素，元素，......};
千万不可写成int[] x=new int[4]{1,2,3,4};，这样写编译器会报错，原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。
2.数组的常见操作
1）数组遍历

public class Example
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};//定义数组
//使用for循环遍历数组的元素
for(int i=0;i<arr.length;i++)
{
System.out.println(arr);
}
}
}

复制代码

2）数组最值

public class Example
{
public static void main(String[] args)
{
int[] arr={4,1,6,3,9,8};//定义一个数组
int max=getMax(arr);//调用获取元素最大值的方法
System.out.println("max="+max);//打印最大值
}
static int getMax(int[] arr)
{
int max=arr[0];//定义变量max用于记住最大数，首先假设第一个元素为最大值
//下面通过一个for循环遍历数组中的元素
for(int x=1;x<arr.length;x++)
{
if(arr[x]>max)//比较arr[x]的值是否大于max
{
max=arr[x];//条件成立，讲arr[x]的值赋给max
}
}
return max;//返回最大值max
}
}

复制代码

3）数组排序

public class Example
{
public static void main(String[] args)
{
int[] arr={9,8,3,5,2};
System.out.print("冒泡排序前：");
printArray(arr);//打印数组元素
bubbleSort(arr);//调用排序方法
System.out.print("冒泡排序后：");
printArray(arr);
}
//定义打印数组方法
public static void printArray(int[] arr)
{
//循环遍历数组的元素
for(int i=0;i<arr.length;i++)
{
Syestem.out.print(arr+" ");//打印元素和空格
}
System.out.print("\n");
}
//定义对数组排序的方法
public static void bubbleSort(int[] arr)
{
//定义外层循环
for(int i=0;i<arr.length-1;i++)
//定义内层循环
for (int j=0;j<arr.length-i-1 ; j++)
{
if(arr[j]>arr[j+1])//比较相邻元素
}
//下面的三行代码用于交换两个元素
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.print("第”+(i+1)+"轮排序后：")；
printArray(arr);
}
}

复制代码

3.多维数组
第一种方式：int[][] arr=new int[3][4]
上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，每个二维数组中的元素又是一个长度为4的数组
第二种方式：int[][] arr=new int[3][]
第二种方法和第一种类似，只是数组中每个元素的长度不确定
第三种方法：int[][] arr={{1,2},{3,4,5,6},{7,8,9}}
上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2},{3,4,5,6},{7,8,9}

IT黑马 · IT黑马

我想说，我是来学习笔记的

j420984 · j420984

笔记内容：常用数组操作
 笔记来源：毕向东Java基础视频第四天
 正文：
 常用数组操作。

遍历

public classLeanr {

public static void main(String args[]) {

 int[]x = { 3, 2, 3, 6, 3, 8,3, 63, 6 };

 for (inti = 0; i < x.length; i++) {

 System.out.print(x[i]+"\n");

 }

}

}

获取最值

public static int getMax(int[]arr) {

 int max = arr[0];

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

 if (arr[i] >max)

 max = arr[i];

 }

 returnmax;

}

public static int getMin(int[]arr) {

 int min = arr[0];

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

 if (arr[i] >min)

 min = arr[i];

 }

 returnmin;

}

如int max=0比较时须将max设为脚标值

选择排序

public static void selectSort(int[]arr) {

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

 for (intj = i + 1; j < arr.length;j++) {

 if (arr[i] >arr[j]) {

 arr[i] =arr[i] ^ arr[j];

 arr[j] =arr[i] ^ arr[j];

 arr[i] =arr[i] ^ arr[j];

 }

 }

 }

}

冒泡排序

public static void bubbleSort(int[]arr) {

 for (inti = 0; i < arr.length; i++) {//for(int i = arr.length-1;x 〉 0；x--)

 for (intj = 0; j < arr.length - i - 1; j++) {//for(int y=0;y<x:y++)

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

 arr[j] =arr[j] ^ arr[j + 1];

 arr[j + 1] =arr[j] ^ arr[j + 1];

 arr[j] =arr[j] ^ arr[j + 1];

 }

 }

 }

}

折半查找

public static int halfSearch(int[]arr, intkey) {

 int min, max, mid;

 min = 0;

 max = arr.length - 1;

 mid = (max +min) / 2;

 while (arr[mid] !=key) {

 if (key >arr[mid])

 min = mid + 1;

 else if (key < arr[mid])

 max = mid - 1;

 if (min >max)

 return -1;

 mid = (max +min) / 2;

 }

 returnmid;

}

xxpotato · xxpotato

笔记内容：数组
笔记来源：毕向东Java基础视频第4天：
正文：
1.函数的定义:
定义：定义在类中，具有特定功能的一小段程序.
2.函数的格式：
格式：
 修饰符返回值函数名（参数类型1 形式参数1，参数类型2，形式参数2 ）
 {
 //方法体
 //return 语句
 }
练习1：
/*
需求：请写一个功能，实现求两个int数中的最大值，
 把最大值返回，并在main方法中进行调用
思路：有返回值吗？有，最大值，int
 有参数吗？有，两个，int，int
*/
class D5HW1
{
public static void main(String[] args)
{
System.out.println(max(3,4));
System.out.println(max(5,4));
System.out.println(max(3,3));
}
public static int max(int a,int b)
{
return a>b?a:b;
}
}

练习2：
/*需求：请编写一个函数完成比较两个int类型数据
是否相等的功能
 思路：1.有返回值吗？有，boolean
 2.有参数吗？有，两个，int，int
 */
class D5HW2
{
public static void main(String[] args)
{
System.out.println(compare(3,3));
System.out.println(compare(3,4));
}
public static boolean compare(int a,int b)
{
return a==b;
}
}

练习3：
/*
需求：根据给定的行数和列数输出组成一个*组成的长方形
（定义一个功能，在主函数中调用）
思路：1.有返回值吗？没有，void
 2.有参数吗？有，两个，行数和列数，int，int
*/
class D5HW3
{
public static void main(String[] args)
{
cfx(3,4);
System.out.println("-------");
cfx(5,6);
}
public static void cfx(int a,int b)
{
for (int x=1;x<=a ;x++ )
{
for (int y=1;y<=b ;y++ )
{
System.out.print("*");
}
System.out.println();
}
}
}

3.函数重载的定义：
 重载是发生在通一个类里面（1分），函数名一样，参数列表不同（个数\ 类型 \ 顺序）（1分），与返回值类型无关，这就是方法的重载。
练习4：

答：B
4.一维数组的定义：
数组：就是存储多个同一种数据类型元素的容器。
5.定义数组的4种方式（掌握）：
int[] arr=new int[5];//必须掌握
-- 变形（int arr1[]=new int[5]//不推荐使用，认识即可，想使用数组的引用，用arr1）
int[] arr2={1,2,3,4,5};//要求数据是什么都要明确
int[] arr3=new int[]{1,2,3,4,5};//理解
练习5：这个程序的输出结果是？

答：10,5
6.一维数组操作（遍历，最值，查找）：
练习6：（**第一遍敲的不熟）
一维数组{1,2,3,4,5,6,7,8,9,0}的遍历。
/*需求：一维数组{1,2,3,4,5,6,7,8,9,0}的遍历。
 思路：1.有返回值吗？没有。
 2.有参数吗？有，一维数组，arr
*/
class D5HW4
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5,6,7,8,9,0};
bianLi(arr);
}
public static void bianLi(int[] arr)
{
for (int x=0;x<arr.length;x++)
{
System.out.print(arr[x]+" ");
}
System.out.println();
}
}

注;不要数有多少个元素，要使用arr.length。
练习7：
一维数组{1,2,3,4,5,6,7,8,9,0}的最值。

Jackron · Jackron

笔记内容：数组笔记来源：刘意java视频第5天
内容:上课的时候，超哥给补充部分内容。

Day05
函数的定义和应用

**定义函数，return返回值**
class function1
{
public static void main(String[] args)
{
 System.out.println(compare(2,4));

}
/*public static boolean eque(int a , int b)
{
if (a==b)
{
return true;
}
}
else
{
return false;
}*/
public static boolean compare(int a , int b)
{
return a==b;

}
}
***重载***
在一个类中，函数名相同，但参数列表不同（包括个数和参数类型），与返回值无关。
***数组***
定义：存储多个元素的容器
格式：元素类型[] 数组名=new 元素类型[元素长度或个数]；
Int[] arr =new int [5]; 另一形式：int arr[] =new int[5]
Int[] arr ={1,2,23,3} Int[] arr =new int [] {1,2,23,3}
;左边：
Int：数据类型
[]:表示是一个数组
Arr：数组名
右边
New：申请内存空间
Int：数据类型
[]:表示是一个数组
5：数组长度
System.Out.println(arr)//[I@7f4e——物理地址
System.Out.println(arr[0])
特点：
1、可以存储基本数据类型，也可以存储引用数据类型
2、一个只能存放同一种数据类型
3、数组的长度固定
**JAVA中对内存**
堆：所有new出来的
栈：变量，或者方法的执行
New出来的实例都存在堆内存里，每一个新new出来的东西都有一个地址值
栈：局部变量：定义在方法中或者方法声明上的形式参数都叫局部变量
当数据使用完毕，就自动从内存中释放。
Null在内存中没有空间没有对象；
多个数组指向同一个堆内存：
例：
class ArrayTest
{
public static void main(String[] args)
{
//定义一个数组
int[] arr=new int [3];
arr[0]=1;
arr[1]=3;
arr[2]=5;
//再定义一个数组
int[] arr2 =arr;
arr2[1]=10;

System.out.println(arr[1]);
System.out.println(arr2[2]);
}
}
练习2：遍历小程序
class ArrayTest
{
public static void main(String[] args)
{
//定义一个数组

//数组遍历
/*System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);*/
/*for (int x=0;x<5 ;x++ )
{
//输出012345
System.out.println(arr[x]);
}*/
/* for (int x=0;x<arr.length ;x++ )
{
//输出012345
System.out.println(arr[x]);
}*/
int[] arr={1,2,3,4,5};
printArray(arr);
}
public static void printArray(int [] arr)
{
for (int x=0;x<arr.length ;x++ )
{
//输出012345
System.out.println(arr[x]);
}
}
}
练习3：遍历获取最大值：

二维数组就是元素是一个一位数组。

3代表3个数组，2代表一个数组中有两个元素；

***数组查找***
class ArrayTest
{
public static void main(String[] args)
{
int [] arr= {4,1,3,5,6,7,8};
int index=getIndex(arr,2);
System.out.println("index="+index);
}
public static int getIndex(int [] arr,int key)
{
for (int x=0;x<arr.length ;x++ )
{
if (arr[x]==key)
{
return x;
}

}
return -1;

}
}
练习4：一维数组倒序遍历
class ArrayTest
{
public static void main(String[] args)
{
int [] arr= {4,1,3,5,6,7,8};
getIndex(arr);

}
public static void getIndex(int [] arr)
{
for (int x=arr.length-1;x>0 ;x--)
{

System.out.println(arr[x]);

}
}
}
练习5：**二维数组遍历**

注：外循环遍历二维数组的每一维数组，内循环遍历一维数组的每个元素。
***二维数组的应用***

class ArrayTest
{
public static void main(String[] args)
{
//二维数组
int [][] arr= {{10,9,8},{16,23,32},{67,112,223},{123,2}};
//每个季度的销售额和年总销售额
int sum=0;

for (int x=0;x<arr.length ;x++ )
{
int sum1=0;
for (int y=0;y<arr[x].length ;y++ )
{

sum1+=arr[x][y];
sum+=arr[x][y];

}
System.out.println("第"+(x+1)+"季度的销售额："+sum1);
}
System.out.println("年销售额："+sum);
}

}

黑马和大灰狼 · 黑马和大灰狼

本帖最后由黑马和大灰狼于 2015-7-12 15:50 编辑

笔记内容：数组
         笔记来源：刘意老师Java基础视频第5天+阳哥笔记结合
         正文：
      数组
   (1)数组是存储同一种类型的多个元素的容器。
         (2)好处：数组中的元素会被自动从0开始编号，方便我们获取。
         (3)格式：
            A:int[] arr = new int[3];　// []中的数字是数组的长度，写成arr.length
            B:int arr[] = new int[3];  //这种写法不建议，建议写成上面的那种写法
            C:int[] arr = new int[]{1,2,3};
            D:int[] arr = {1,2,3};//喜欢这种写法，更加简单哦

Java在内存中的存储情况：
java在启动时，一共在内存中开辟了五块空间来进行自己数据的存储。
包括：栈内存，堆内存，（方法区，本地方法区，寄存器）。每片内存区域中处理数据的方式不一样，因此才划分那么细。
栈内存特点：数据使用完毕，会自动释放。记住，凡是局部变量，都在栈内存里。
堆内存：堆里面存放的都是实体，实体包括数组和对象。凡是new创造出来的实体，都是在堆内存中。
特点：
1、堆内存中的每一个实体，都有一个内存地址值。
2、堆内存中的实体是用来封装数据的，而对内存中的实体中的数据都有默认初始化值。这个值依据元素类型而定，int型默认为0，double默认为0.0，float为0.0f，boolean型为false。
3、垃圾回收机制。
//注意点：Null常量只有引用数据类型才能使用。
//如果将一个数组x[]赋值成null，则不知道了堆内存中数据的初始地址，则和对应的实体就没关系了。
//当一个实体在堆内存中没有任何引用所使用时，java虚拟机就视他为垃圾，并会不定时（内存快要满的时候）的启动一个垃圾回收机制，将数组实体在堆内存中清除。

数组的操作：
1、获取数组中的元素，这是数组中最常用到的操作，通常会用到遍历。
2、数组中有个属性，可以直接获取到数组的数组元素的个数。Length
使用方式：数组名称.length
通常情况下，用到数组的时候，都要用到for循环。

/*重要代码1: 遍历并打印数组元素,就是全部打印一遍*/
class Test1 {
public static void main(String[] args) {
int[] arr = {89,34,270,17};
for(int x = 0; x < arr.length; x += 1){
System.out.println("arr[" + x + "] = " + arr[x] + ";");
}
}
}

复制代码

/*重要代码2：比较大小
思路:
1、需要进行比较，并定义变量记录住每次比较后较大的值。
2、对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
如果遍历到的元素大于变量中记录的元素，就用变量该记录住大的值。
3、遍历结果，该变量记录就是最大值。*/
class Test1{
public static void main(String[] args){
int[] arr = {21,89,73,64,4,2,6,3,3};
int max = getMax( arr);
System.out.println("max="+max);
}
public static int getMax(int[] arr){
int maxElement = arr[0];
for(int x=1 ;x<arr.length ;x++){
if(arr[x]> maxElement){
maxElement = arr[x];
}
}
return maxElement;
}
}

复制代码

/*
重要代码2：排序（冒泡排序、选择排序）
思路：
1、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元
素，就互换内容。
2、经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和
其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第二个元素就是数组中倒数
第二小的元素。
3、依次类推，直到最后一个元素。*/
class Test1{
public static void main(String[] args){
int[] arr = {1,2,5,4,9,100,1000,152,901};
System.out.println("排序前数组");
printArry(arr);
System.out.println("排序后的数组");
selectSortArry(arr);
printArry(arr);
}
public static void selectSortArry(int[] arr){
for (int x=0;x<=arr.length-2 ;x++ ){
for (int y=x+1;y<=arr.length-1;y++ ){
if(arr[x]>arr[y]){
int temper = arr[x];
arr[x] = arr[y];
arr[y] = temper;
}
}
}
}
public static void printArry(int[] arr){
for (int x=0;x<arr.length ;x++ ){
System.out.print(arr[x]+"\t");
}
System.out.println();
}
}

复制代码

//自己改进的排序和遍历打印合并在一起的代码
class Test1{
 public static void main(String[] args){
 int[] arr = {1,2,5,4,9,100,1000,152,901};
 printArry(arr);

 }
 public static void printArry(int[] b){
 for (int x=0 ;x<=b.length-2 ;x++ ){
 for (int y=x+1 ;y<=b.length-1 ;y++ ){
 if (b[x]>b[y]){
 int temper = b[y];
 b[y] = b[x];
 b[x] = temper;
 }
 }
 }
 for (int z=0;z<=b.length-1 ;z++ ){
 System.out.print(b[z]+"\t");
 }
 }
}

//冒泡排序
class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
System.out.print("排序前数组：" );
printArray(arr);
bubbleSort(arr);
System.out.print("排序后数组：" );
printArray(arr);
}
public static void bubbleSort(int[] arr){
for(int x = 0; x < arr.length - 1; x++){
for(int y = 0; y < arr.length - 1 -x; y++){
if(arr[y] > arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[" );
for(int x = 0; x < arr.length; x++){
if(x != arr.length - 1)
System.out.print(arr[x] + "," );
else
System.out.println(arr[x] + "]" );
}
}
}

复制代码

我是新生 · 我是新生

我没有专门做数组的笔记,不过我们java基础班第六天就是讲了数组,这是我第6天自己总结的笔记

1.重要的知识点.
2.一些好的习惯或者重要的注意事项.
3.可能出现的面试题.

重要的知识点
1.函数
定义:在类中的一小段具有特定功能的程序
作用:可以提高代码的复用性和维护性
格式:
修饰符返回值类型(没有就写void) 方法名(参数类型1 形式参数1,参数类型2 形式参数2,...)
{
//方法体;
//return 语句;
}
特点:
函数是平级关系,不能嵌套
函数只有被调用才会被执行.
调用方法:
单独调用:一般用于没有返回值,其类型为void的时候
输出调用:System.out.println(方法名());
赋值调用:方法中返回值是什么类型就用什么类型接收.(不要忽略类型自动转换的问题)
结束方式:
关键字return让方法结束
返回值类型是void的方法,return语句可以省略
定义方法的思路:
1.明确有无返回值,类型是什么
2.明确有无参数,类型是什么,数量是多少
2.数组
定义:存储多个同一数据类型的元素的容器
作用:元素会具备索引,方便操作
特点:
可以存储基本数据类型,也可以存储引用数据类型
一个只能存储同一种数据类型
数组的长度一旦定义就固定
格式:
元素类型[] 数组名 = new 元素类型[长度];
直接打印数组:看到数组在内存中的地址值的十六进制表现形式
获取元素格式:
数组名[索引]
定义方式:(以int型数组为例)
int[] arr1 = new int[3];
int[] arr2 = new int[]{1,2,2};
int[] arr3 = {2,5,5};
数组操作的常见问题:
ArrayIndexOutOfBoundsException//索引越界异常
NullPointerException//空指针异常
数组遍历:就是取出数组中的所有元素的操作
特殊情况:
int[] arr = null;
int[] arr = new int[];//长度为0

3.内存
栈:
局部变量
特点:使用完毕自动消失
堆:
new建立出来的实例
全局变量:都有默认初始化值
整型:0
浮点型:0.0
字符型:'\u0000'(空字符)
布尔型:false
引用类型:null
特点:会在变成垃圾后(没有引用指向),被垃圾回收站不定时的回收.
4.二维数组
格式:
数据类型[][] 变量名 = new 数据类型[n][m];
数据类型[][] 变量名 = new 数据类型[n][];
数据类型[][] 变量名 = {{2,5},{6,8},{5,5},{,4,7}};
遍历二维数组:外循环遍历二维数组,得到每一个一维数组,内循环遍历一维数组.
注意事项:数组的长度不要去数,通过数组名.length获取

重要注意事项
1.函数格式,函数是平级关系,在同一个类中不能嵌套,只能并列存在.
2.函数重载
3.数组格式,内存图要会画,然后数组的使用(遍历,求最值,查找)
4.二维数组格式,内存图要会画

可能出现的面试题
函数的重载

冷风然 · 冷风然

本帖最后由冷风然于 2015-7-12 00:04 编辑

java基础刘意老师
下面是根据刘老师的视频和超哥的讲解做的总结
2.数组
 数组:就是存储多个同一种类型元素的容器
 好处有索引,方便操作
 格式
 格式一:元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
 例子: int[] arr = new int [5];
 数据类型：基本类型：4类8种.引用类型：类,接口,数组
 左边：int:表示数据的类型。
 []:表示这是一个数组。
 arr:数组的名字
 右边：new:申请内存空间。
 int:表示数据的类型。
 []:表示这是一个数组。
 5:数组的长度。
 System.out.println(arr);会获取地址
 格式二:元素类型[] 数组名 = new 元素类型[]{元素1,元素2......}
 例子:int[] arr = new int[]{1,2,5,3,6};
 格式三:元素类型[] 数组名 ={元素1,元素2......};
 例子:int[] arr = {1,2,5,3,6};
 常见问题
 A:数组越界异常。你访问了不存在的索引。
 ArrayIndexOutOfBoundsException
 B:空指针异常。一个实例(对象)已经不存在了，你还去访问它的内容。
 NullPointerException
 数组遍历
 int[] arr ={1,4,2,5,6,3,8,};
 for (int x = 0;x<arr.length ;x++ )
 {
 System.out.println(arr[x]);
 }
 数组求最大值
 int max = arr[0];
 for (int y = 0;y < arr.length ;y++)
 {
 if (max < arr[y])
 {
 max = arr[y];
 }
 }
 System.out.println(max);
 二维数组：其实就是元素是一个一维数组。
 索引：角标,下标,编号。
 格式：方式1:
 int[][] arr = new int[3][2];
 解释：定义了名称为arr的二维数组
 二维数组中有3个一维数组
 每一个一维数组中有2个元素
 一维数组的名称分别为arr[0], arr[1], arr[2]
 给第一个一维数组1索引位赋值为78写法是：arr[0][1] = 78;
 二维数组定义格式：
 方式1：int[][] arr = new int[3][2];
 规则的矩形。
 方式2：int[][] arr = new int[3][];
 二维数组中有3个一维数组
 每个一维数组都是默认初始化值null
 可以对这个三个一维数组分别进行初始化
 arr[0] = new int[3];
 arr[1] = new int[1];
 arr[2] = new int[2];
 非规则的矩形。
 方式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
练习
 一位数组的遍历和求最大值的主要代码已在上面,下面是数组查找和二维数组遍历的代码

 数组查找
 class ArrayTest
 {
 public static void main(String[] args)
 {
 int [] arr= {4,1,3,5,6,7,8};
 int index=getIndex(arr,2);
 System.out.println("index="+index);
 }
 public static int getIndex(int [] arr,int key)
 {
 for (int x=0;x<arr.length ;x++ )
 {
 if (arr[x]==key)
 {
 return x;
 }
 }
 return -1;
 }
 }
 二维数组的遍历
 class Array2Demo3
 {
 public static void main(String[] args)
 {
 //二维数组的遍历
 int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
 //arr.length 获取二维数组的长度，其实也就是一维数组的个数
 //arr[x].length 获取的是每一个一维数组的长度
 //arr[x][y] 获取的是二维数组的元素
 for(int x=0; x<arr.length; x++)
 {
 for(int y=0; y<arr[x].length; y++)
 {
 System.out.print(arr[x][y]+"\t");
 }
 System.out.println();
 }
 }
 }

joe520kay · joe520kay

本帖最后由 joe520kay 于 2015-7-22 14:23 编辑

笔记内容：数组
笔记来源：毕向东Java基础视频第4天正文
正文：
一、数组的定义：
Java的数组要求所有的数组元素具有相同的数据类型。Java语言支持两种语法格式来定义数组：

第一种：int[] arr =newint[2] 或 int arr[] = new int [2]

第二种：静态初始化：int[]arr = new int[]{2,1,4,5} 或 int [] arr ={2,9,7,5}

动态初始化：int [] arr = new int[5]

arr[0] = 90;

arr[1]= 92;

二、数组的操作：

1、获取数组中的元素。通常会用到遍历

int [] arr = new int [3];
for(int x= 0;x<3;x++)
{
System.out.println("arr["+x+"]="+arr[x]+";")
}

复制代码

数组中有一个属性可以直接获取到数组元素个数：length

使用方式：数组名称.length

int []arr = {3,8,7,6,0,4}

复制代码

{

System.out.println("arr["+x+"]="+arr[x]+";")

//求和

sum += arr[x];

}

2、数组的查找

重点介绍折半法查找

代码如下：

package com.joe.arr;
public class ArrTest {
public static void main(String[] args) {
int[] arr = { 2, 12, 18, 27, 35, 40, 53, 69 };
int index = getIndex(arr, 2);
System.out.println("index=" + index);
int index2 = getIndex(arr, 27);
System.out.println("index=" + index);
}
/*
* 折半查找，提高效率，必须保证该数组是有序的数组。
*/
public static int halfSearch(int[] arr, int key) {
int min, max, mid;
min = 0;
max = arr.length - 1;
mid = (max + min) / 2;
while (arr[mid] != key) {
if (arr[mid] > key)
min = mid + 1;
else if (arr[mid] < key)
max = min - 1;
if (min > max)
return -1;
mid = (max + min) / 2;
}
return mid;
}
/*
* 折半的第二种方式
*/
public static int halfSearch_2(int[] arr, int key) {
int min = 0, max = arr.length - 1, mid = 0;
while (min <= max) {
min = (max + min) >> 1;
if (key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
}

复制代码

白羽蘇芳 · 白羽蘇芳

笔记内容：数组
笔记来源：黑马程序员_毕向东最新经典Java基础视频day04
正文：
1、数组的定义

概念：
同一种类型数据的集合。数组就是一个容器。

数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 比如
int[] arr = new int[3];
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,6,1,7,8}
int[] arr = {3,6,1,7,8}

2、内存的结构

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

内存的划分：方法区、本地方法区、寄存器。栈内存、堆内存。

栈内存：
·用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。
// for（int x =1，x<5,x++）這里的x就是放在栈内存中，for循环一结束，就释放掉了。

堆内存：
·数组和对象，通过new建立的实例都存放在堆内存中。
//new出来的实体不会消失，除非设置为null之后，才会被jvm当作垃圾回收。

· 每一个实体都有内存地址值。
/*
int[] x = new int [1,2,3,4,5]
int[] y = new int [1,2,3,4,5]
這里x与y指向的是两个数组，虽然他们数据相同，但是两个数组有2个内存地址。
*/

·实体中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean 是false，char类型是'\u0000'。
/*
int[] x = new int [3]
System.out.println(arr[0]);
System.out.println(arr[1]);
打印结果都是0，因为int类型默认初始值为0；
*/

·如果将数组的引用实体设置为null，也就是实体不再被使用，那么会在不确定的时间内被垃圾回收器回收。
/*
int[] x = new int [3]
x = null；
null了这个实体就变成垃圾了，JVM会在个神秘的时间把它干掉
*/

例1：

class ArrDemo
{
public static void main(String[] args)
{
int[] x = new int [3]; //栈内存里变量x，堆内存里创立包含3个角标的数组；
int[] y = x; //栈内存里变量y和x共同指向那个数组；
y[1] = 39; //y把1号角标的数据变更为39；
System.out.println(x[1]);//x回来取出1角标的数据，因为被更改了，所以打印出来39；
}
}

复制代码

结果为：

那么如果是这种情况呢
int a=5;
int b=a;
b=8;
System.out.println(a);

结果a是几？肯定是5啊读一遍看看
5赋值给a
a赋值给b，所以b=5
8赋值给b，所以b=8
打印a，a不还是5么。和例1一对比，這就是栈内存和堆内存的区别。

3、常见问题
例2：

class ArrayDemo{
public static void main(String[] args){
int[] arr = new int[3];
System. out.println(arr[3]);//这个数组只包括arr
}
}

复制代码

new出来的数组只包括arr[0] arr[1] arr[2]，你打印个arr[3]，它当然找不到了
数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生。

例3：

class ArrayDemo{
public static void main(String[] args){
int[] arr = null;
System. out.println(arr[0]);
}
}

复制代码

空指针异常(NullPointerException)：当引用型变量没有指向任何实体时，用其操作实体，就会发生该异常。

4、常见操作
数组的操作：
获取数组中的元素，通常会用到遍历。
数组中有个属性，可以直接获取到数组中的元素个数：length
用法：数组名称.length
例4：

/*
遍历数组
*/
class ArrayDemo1
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67};
System.out.println("length="+arr.length);
for (int x = 0; x<arr.length ; x++ )
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
}
}

复制代码

引申下，如果要得出数组所有元素的和呢？用累加思想

int sum = 0;for (int x = 0; x<arr.length;x++);{sum += arr[x];}

复制代码

再引申下，定义一个功能打印数组并且用逗号隔开

class ArrayDemo1
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67};
printArray(arr);
}
public static void printArray (int[] arr)
{
for (int x = 0; x<arr.length ; x++ )
{
System.out.print(arr[x]+",");
}
}
}

复制代码

后面多一个逗号，不爽，搞掉他。

class ArrayDemo1
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67};
printArray(arr);
}
public static void printArray (int[] arr)
{
for (int x = 0; x<arr.length ; x++ ) //前面都一样，for里面嵌套个if语句
{
if (x<arr.length-1)
//总共有7个，最后一个是arr[6]，让x<6的时候才打印逗号
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
}

复制代码

如果直接System.out.print(arr);那么结果就是

[表示的是数组
I表示的是int
@de6ced表示的是這个数组初始地址的hash值。

例5：给定一个数组{5,1,6,4,2,8,9},获取最大值与最小值。

/*
给定一个数组{5,1,6,4,2,8,9},获取最大值与最小值。
思路：
1，定义个变量，把arr[0]赋值给他
2，让数组中每个数都跟变量比较，比他大就赋值给他
3，定义个函数，两个明确
返回结果是最大值，是个值，所以是int
参数内容，是个数组。
*/
class ArrayTest
{
public static void main(String[] args)
{
int[] arr = new int[]{5,1,6,4,2,8,9};
int max = getMax(arr);
int min = getMin(arr);
System.out.println("max="+max);
System.out.println("min="+min);
}
public static int getMax(int[] arr) //将arr放到函数里来
{
int max = arr[0]; //把0角标的数先赋给max
for (int x = 1 ; x<arr.length; x++ )
{
if (arr[x]>max) //如果arr[1]大于max，就把值赋给max，通过for循环遍历arr[x]
max = arr[x];
}
return max; //将max返回给函数
}
public static int getMin(int[] arr)
{
int min = arr[0];
for (int x = 1 ; x<arr.length; x++ )
{
if (arr[x]<min)
min = arr[x];
}
return min;
}
}

复制代码

------------------------------------------------------
第一次写帖子居然说超字节了= =，分层发吧

白羽蘇芳 · 白羽蘇芳

例6：对给定数组进行排序{5,1,6,4,2,8,9}
方法一：选择排序，思路是arr[0]分别与后面的数比较，碰到小的就让小的到前面来，最后最小的肯定在arr[0]的位置上，然后让arr[1]与后面的比，如此循环，得到排序。

class ArrayTest2
{
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; //变量里的数取出来放到后面去
}
}
return;
}
public static void printArr(int[] arr) //定义一个打印的函数
{
System.out.print("[");
for (int x = 0 ; x<arr.length ;x++ )
{
if (x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr ={5,1,6,4,2,8,9};
selectSort(arr);
printArr(arr);
}}

复制代码

方法二：冒泡排序
思路：让arr[0]与arr[1]，arr[1]与arr[2]这种相邻2个数比较，大的去后面，在最后的就是最大的数了，循环上述过程，不过第二次只需要循环到倒数第二位，如此循环即可排序

/*
{5,1,6,4,2,8,9} 冒泡排序
*/
class ArrayTest3
{
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++ ）
// -x：让每次比较的数变少，-1：为了不让y+1那个角标越界
{
if (arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void printArr(int[] arr)
{
System.out.print("[");
for (int x = 0; x<arr.length ;x++ )
{
if (x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
bubbleSort(arr);
printArr(arr);
}
}

复制代码

实际开发时，上面什么选择排序、冒泡排序统统不用，java提供了API供我们调用

import java.util.*;
/*
{5,1,6,4,2,8,9} 冒泡排序
*/
class ArrayTest3
{
public static void printArr(int[] arr)
{
System.out.print("[");
for (int x = 0; x<arr.length ;x++ )
{
if (x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
Arrays.sort(arr);
printArr(arr);
}
}

复制代码

实际开发中，2句紫色的语句，就搞定了。

在上面两种排序方法中，有个部分是重复的，都是通过定义第三方变量来实现数组中两个数据的位置互换。那么我们可以定义一个函数来实现这个功能。

public static void swap(int[] arr,int a,int b){ int temp = int a; int a = int b; int b = temp;
}

复制代码

有了个东西，像冒泡排序的這一段

if (arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}

复制代码

就可以写成

if (arr[y]>arr[y+1] swap (arr,y,y+1);

复制代码

就搞定了。

例7：遍历查找

/*
遍历查找{3,1,5,4,2,9}
*/
class ArrayTest4
{
public static int getIndex(int[] arr,int key)
{
for (int x=0 ; x<arr.length ;x++ ) //角标从0开始自增到角标最大值
{
if (arr[x]==key) //如果找到了指定的值
return x; //返回此值的角标给函数以供调用
}
return -1; //找不到，说明数组中没有，返回个-1
}
public static void main(String[] args)
{
int[] arr = {3,1,5,4,2,9};
int Index = getIndex(arr,2);
System.out.println("Index="+Index);
}
}

复制代码

无序数组可以通过遍历查找。如果是有序数组，那么还有更高效的方法：折半查找。

例8：折半查找
方法一：以key是否等于arr[mid]为条件进行循环，直到找到目标为止。

/*
折半查找能提高效率，但要保证是有序排列的数组
*/
class ArrayTest5
{
public static void main(String[] args)
{
int[] arr = {2,4,5,7,19,32,45};
int Index = halfSearch(arr,32);
System.out.println("Index="+Index);
}
public static int halfSearch(int[]arr,int key)
{
int min=0;
int max=arr.length-1;
int mid=(min+max)>>1; //右移1就是除2的1次方，复习一下
while (key!=arr[mid]) //当key不等于中间角标的数时，
{
if (key<arr[mid]) //如果key小于中间的数
max = mid-1; //最大角标mid-1
else if (key>arr[mid])//否则如果key大于中间的数
min = mid+1; //最小角标为mid+1
if (min>max) //如果min大于max了，说明数组不存在key
return -1; //返回-1
mid = (max+min)/2;
//min或max改变一次后，缩小了一半的范围，重置下mid，继续循环查找key
}
return mid; //直到找到了key，跳出循环
}
}

复制代码

方法二：以min<=max为循环条件，一直减半查找，直到找到目标。

/*
折半查找能提高效率，但要保证是有序排列的数组
*/
class ArrayTest5
{
public static void main(String[] args)
{
int[] arr = {2,4,5,7,19,32,45};
int Index = halfSearch(arr,32);
System.out.println("Index="+Index);
}
public static int halfSearch(int[]arr,int key)
{
int min = 0,max = arr.length-1,mid;
mid = (min+max)>>1;
while (min<=max)
{
mid = (min+max)>>1;
if (key<arr[mid])
max = mid-1;
else if (key>arr[mid])
min = mid+1;
else
return mid;
}
return -1;
}
}

复制代码

方法一和方法二的结果自然都是一样的。
那么引申下，如果要往数组中插入个8呢，往哪插？
只需上面的return mid改成return min即可。为什么？
{2,4,5,7,19,32,45}插入8，以方法二为例，
min = 0 ，max = 6，mid=（0+6）/2=3，
arr[3]=7，key>arr[3], min=mid+1;
8是不是就是插在7后面的一个位置啊，那就是min了呗，返还给函数即可

学了数组和函数，现在用学过的只是再来见一下老朋友，进制转换。

例9：十进制转二进制

class ArrayTest6
{
public static void main(String[] args)
{
toBin(6);
}
public static void toBin(int num)
{
while (num>0)
{
System.out.println(num%2); //二进制就是一个数模2的结果，一个数除2不是0就是1
num = num/2; //模2后再除2，继续循环
}
}
}

复制代码

6的二进制是110，出来了，看着不太爽，改一下

class ArrayTest6
{
public static void main(String[] args)
{
toBin(6);
}
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer(); //建立个对象用来装东西
while (num>0)
{
//System.out.println(num%2); 不打印了，将模2的结果装进容器里
sb.append(num%2); //将模2的结果装到sb里去,从尾数往里装，结果是反的啊
num = num/2;
}
System.out.println(sb.reverse()); //reverse反转过来打印结果
}
}

复制代码

哦了
-------------------------------------------------------------
我是不是太话痨了。。笔记应该言简意赅？居然还超字节。。。话说不会被认为在灌水吧=，=

白羽蘇芳 · 白羽蘇芳

例10：十进制转十六进制

class ArrayTest7
{
public static void main(String[] args)
{
toHex(60);
}
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for (int x = 0; x<8 ; x++ )
{
int temp = num & 15; //与个15，取出二进制的最后4位存进变量
if (temp>9)
sb.append((char)(temp-10+'A')); //大于9,16进制是字母，转换成字母
else
sb.append(temp); //小于9的直接存起来
num = num>>>4; //右移4位，继续循环
}
System.out.println(sb.reverse()); //反转打印
}
}

复制代码

查表法
将所有元素临时储存起来，建立对应关系，根据运算结果作为角标去查建好的表，取出对应的元素，就叫查表法
以十进制转十六进制为例：

num & 15,得出的是num二进制的最后四位，将这四位数转换成十六进制的字符就是最后一位了。
然后把num右移4位，继续&15，得出的后四位就是十六进制的倒数第二位。
以此循环，直到右移4位之后，num剩下的全是0了，就不用再运算了

相同的道理，
十进制转二进制就是&1再右移1
十进制转八进制就是&7再右移3 这个不懂的，回去看看第二篇文章进制那地方。

例11：求十进制整数的二进制、八进制、十六进制的表现形式

class ArrayDemo
{
public static void main(String[] args)
{
toHex(60);
toBin(-6);
}
//十进制-->二进制
public static void toBin(int num) {
trans(num,1,1);
}
//十进制-->十六进制
public static void toHex(int num) {
trans(num,15,4);
}
//十进制-->八进制
public static void toOctal(int num){
trans(num,7,3);
}
//进制转换的通用方法
public static void trans(int num, int base,int offset) //base就是&的数，offset就是右移的数
{
if(num == 0)
{
System.out.println("0" ); //当num=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) //num只要还不为0
{
int temp = num & base; //就执行&操作，得出所求进制的最后一位
arr[--pos] = chs[temp]; //到chs里找到对应的符号，赋值到数组arr中的最后1,2,3...位
num = num >>> offset; //右移
}
System.out.println("pos = " + pos); //这里得出的是有效数字，前面都是0或者负数的话就是1了
for(int x = pos; x < arr.length; x++) //比如十六进制arr长度是8个，角标0~7
{ //pos是有效位，如果是3，那么打印的就是arr[5][6][7]
System.out.print(arr[x]);
}
System.out.println();
}
}

复制代码

当然就跟排序似的，真实开发中不会让干這么恶心的事，有API呢，直接调用就搞定了，

class ArrayDemo
{
public static void main(String[] args)
{
System.out.println(Integer.toHexString(60));
}
}

复制代码

5、二维数组
二维数组就是数组中的数组。
格式一：int[][]arr = new int [3][2]
定义了一个二维数组，名称为arr
二维数组中有3个一维数组
3个一维数组的名称为arr[0] arr[1] arr[2]
每个一维数组中有2个元素
给第一个一维数组中的角标1的元素赋值为 int[0][1]=78;

格式二：int[][]arr = new int [3][]
这个二维数组中有3个一维数组
每个一维数组的初始化值都是null
可以分别对一维数组进行初始化：
arr[0] = new int [3];

例12：打印二维数组的和

/*
打印二维数组{{3,5,1,7},{2,3,5,8}{6,1,8,2}}
*/
class Arr2Demo
{
public static void main(String[] args)
{
int[][]arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum=0;
for (int x = 0; x<arr.length ; x++ ) //把每个一维数组加起来
{
for (int y = 0 ;y<arr[x].length ; y++ ) //求单个一维数组的和
{
sum = arr[x][y]+sum;
}
}
System.out.println("sum="+sum);
}
}

复制代码

练习：
定义  int[] x,y[]，以下选项可不可以成立。
a. x[0]=y;
b. y[0]=x;
c. y[0][0]=x;
d. x[0][0]=y;
e. y[0][0]=x[0];
f. x=y

回顾一下：
定义一维数组可以是：int[] x ,int x[];
定义二维数组可以是：int[][]  y, int  y[][],    int[]  y[];
那么题设中的 int[]  x,y[]什么意思呢，拆解开来就是
int[] x;
int[] y[];
定义了一个一维数组x，定义了一个二维数组y。

这样选项就很容易判断了：
a. x[0]=y;             左边是一维数组中的一个值，右边是个二维数组， error。
b. y[0]=x;             两边都是一维数组，yes。
c. y[0][0]=x;       左边是一个值，右边是一维数组，error
d. x[0][0]=y;          x根本就不是二维数组，左边就写错了，error
e. y[0][0]=x[0];    左边是一个元素，右边也是一个元素，yes
f. x=y                   左边一维数组，右边二维数组，error。

---------------------------------------------------------------------------------------
终于写完了

帐号		自动登录	找回密码
密码			加入黑马

[其他交流] ”数组“笔记提交专用帖

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

黑马土豪金