黑马程序员技术交流社区

标题: ”数组“笔记提交专用帖 [打印本页]

作者: 温暖的小白 时间: 2015-5-12 22:18
标题: ”数组“笔记提交专用帖
本帖最后由温暖的小白于 2015-5-12 22:45 编辑

本帖为”数组“笔记分享提交专用帖，只能回复有关”数组“的Java笔记，不得回复与活动主题无关的帖子。

回复格式如下：
      笔记内容：**********
      笔记来源：毕向东Java基础视频第*天
      正文：
         **********
添加代码时请选择编辑器上面的”添加代码文字“。

凡是不按要求回复的帖子一律不得加分。

奖惩规则见活动帖：点击查看{活动帖}

勤奋学习，欢乐得分，正在进行中......

作者: anywayDo 时间: 2015-5-13 00:08
笔记内容：数组
笔记来源：毕向东Java基础视频第4天
正文：
1、数组。
数组是用于存储数据的一种方式。数组中数据的类型可以是任意的，但是一次放进去的，只能是同种类型的元素。
数组的好处：能自动给存进去的数据编号，方便操作这些数据。编号从零开始。
数组的定义格式1：元素类型[] 数组名=new 元素类型[元素个数或数组长度]。其中new是一个新的关键字，用来在内存中产生一个容器实体。数组是一种单独的数据类型，属于引用数据类型。
格式2：元素类型[] 数组名=new 元素类型[]{元素，元素……}。
Int[] arr=new int[]{2,6,7,3,2,5};或者
Int[] arr={2,6,7,3,2,5};
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、使用零角标位上的数和其后面的元素进行比较，如果比它大，则两者交换位置，否则，不用做任何操作。这样就得到了最大的数。
2、使用1角标上的数和其后面的元素进行挨个比较，同上面的方法，找出第二大的数。
3、这样就得到了从大到小的顺序数组。
选择排序中，内循环结束一次，最值出现在头角标上。

/*
需求：对给定数组进行排序，{5,1,6,4,2,8,9}，按照从大到小的顺序。并定义成一个功能，以提高代码的复用性。使用选择排序算法。
思路：1、使用零角标位上的数和其后面的元素进行比较，如果比它大，则两者交换位置，否则，不用做任何操作。这样就得到了最大的数。
2、使用1角标上的数和其后面的元素进行挨个比较，同上面的方法，找出第二大的数。
3、这样就得到了从大到小的顺序数组。
步骤：1、先定义一个变量，代表数组的角标。
2、定义一个for循环，将arr[0]和其后的元素进行比较，将最大的数交换到arr[0]
3、然后用arr[1]和其厚度元素比较，最后得出结果。
*/
class ArrayTest1
{
public static void main(String[] args)
{
int[] arr={5,1,6,4,2,8,9};
printarray(arr);
select(arr);
printarray(arr);
}
public static void select(int[] arr)//选择排序
{
for(int x=0;x<arr.length;x++)
{
for(int y=x;y<arr.length;y++)
{
if(arr[x]<arr[y])
{
int temp=arr[y];
arr[y]=arr[x];
arr[x]=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.print(arr[x]);
}
}
System.out.println('}');
}
}

复制代码

二、冒泡排序
算法：相邻的两个元素进行比较，如果符合条件就换位。第一圈排完，最值出现在了最后位。

/*
需求：使用选择冒泡算法。对给定数组进行排序，{5,1,6,4,2,8,9}，按照从小到大的顺序。并定义成一个功能，以提高代码的复用性。
思路：1、相邻的两个数相比较，如果后者小，则两者换位置，那么到最后比完，最大的数就到了最后面的位置。
2、然后从头开始比，到倒数第二个元素时就不用比了。
3、这样就得到了一个从小到大顺序排列的数组。
*/
class ArrayTest3
{
public static void main(String[] args)
{
int[] arr={5,1,6,4,2,8,9,19,50,30,60};
printarray(arr);
bubblesort(arr);
printarray(arr);
}
public static void bubblesort(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=1;y<arr.length-x;y++)
{
if(arr[y]<arr[y-1])
{
int temp=arr[y-1];
arr[y-1]=arr[y];
arr[y]=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.print(arr[x]);
}
}
System.out.println('}');
}
}

复制代码

发现：无论什么排序，都需要对满足条件的元素进行位置置换，所以可以把相同的代码提取出来，单独封装成一个函数。
（二）数组的查找操作：
1、把数组中所有的元素遍历一遍，如果与所查找数相等，则返回其角标，这种方法代码简单，但是效率不高。
2、折半查找：提高效率，但是必须要保证该数组是有序的数组。要记得，将查找的关键字和数组中间的元素比较后，要对mid值重新赋值，变为改变后的Mid=(min+max)/2。
Min=0；
Max=arr.length-1;
Mid=(min+max)/2;
while(key!=arr[mid])
 {
 if(key>arr[mid])
 min=mid+1;
 else if(key<arr[mid])
 max=mid-1;
 mid=(min+max)/2;
 if(min>max)
 return -1;
 }
 return mid;

这是为什么将一个数插入一个有序数组时，如果该元素存在于数组中，则返回mid，如果不存在，则返回min的原因。
一、二维数组
1、定义格式1：int[] [] arr=new int[2][3];
这样就定义了一个二维数组，数组名为arr，包含两个一维数组，每个一维数组的长度为3.
一维数组的名称分别为arr[0],arr[1],arr[2]。给第二个二维数组的第三个元素，即角标为2的元素赋值89的写法是：arr[1][2]=89.第一个数组的长度表示方法：arr[0].length.
定义格式2：int[][] arr=new int[3][];
定义了一个长度为3的二维数组，其中每一个一维数组的默认初始化值为null，可以对他们分别初始化： arr[0]=new int [3];

二维数组的小练习：
一维数组中，int[] x;int x[];这两种定义方法都是可以的。
二维数组中，int[][] y;int[] y[];int y[][];这三种定义方法也都是可以的。
那么int[] x,y[];这样定义，则表示x是一个一维数组，y是二维数组。
相当于int[] x; int[] y[];（但是一边不这样定义，只是考试或面试题中会这样定义。）

作者: c523106 时间: 2015-5-13 00:54
本帖最后由 c523106 于 2015-5-13 00:57 编辑

笔记内容：数组
笔记来源：毕向东Java基础视频第4天
正文：
一、数组的定义：存储同一种数据类型的多个元素的容器。
二、定义格式：
1:数据类型[] 数组名;
2:数据类型数组名[];（了解即可）
三、数组的初始化
1、数据类型[] 数组名=new 数据类型[数组长度];
         举例：int[] arr = new int[3];
2、数据类型[] 数组名=new 数据类型[]{存储元素};
         举例：int[] arr = new int[]{1,2,3};
         简写：int[] arr = {1,2,3};
四、数组的常见操作
1.遍历，获取最值，逆序，查找

package cn;
import java.util.Scanner;
/**
* 数组遍历(依次输出数组中的每一个元素)
* 数组获取最值(获取数组中的最大值最小值)
* 数组元素逆序 (就是把元素对调)
* 数组查表法(根据键盘录入索引,查找对应星期)
* 数组元素查找(查找指定元素第一次在数组中出现的索引)
*/
public class ArrayTest {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 3, 6, 3 };
// method1(arr);
// getMax(arr);
// reverseArr(arr);
// find();
findIndex(3 ,arr);
}
public static void findIndex(int num,int[] arr) {
// TODO Auto-generated method stub
int count=0;
for(int x:arr){
if(x==num){
System.out.println(count);
break;
}
count++;
}
}
public static void find() {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
System.out.println("请输入索引：");
int index = sc.nextInt();
int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
System.out.println(arr[index - 1]);
sc.close();
}
public static void reverseArr(int[] arr) {
// TODO Auto-generated method stub
for (int x = 0; x < arr.length / 2; x++) {
int temp = arr[x];
arr[x] = arr[arr.length - x - 1];
arr[arr.length - x - 1] = temp;
}
method1(arr);
}
public static void getMax(int[] arr) {
// TODO Auto-generated method stub
int max = 0;
for (int x : arr) {
if (max < x) {
max = x;
}
}
System.out.println(max);
}
public static void method1(int[] arr) {
// TODO Auto-generated method stub
for (int x : arr) {
System.out.println(x);
}
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
}
}

复制代码

2.二分查找

package cn;
/**
* 二分查找。（针对有序数组，不要为了用二分查找，而排序）
* @author cz
*
*/
public class Test6 {
public static void main(String[] args) {
int[] array={1,2,3,5,6,8,9};
System.out.println(binarySearch(6,array));
}
public static int binarySearch(int i, int[] array) {
// TODO Auto-generated method stub
int max=array.length-1;
int min=0;
int mid=(max+min)/2;
while(i!=array[mid]){
if(i>array[mid]){
min=mid+1;
}else if(i<array[mid]){
max=mid-1;
}
mid=(max+min)/2;
}
return mid;
}
}

复制代码

3、排序

package cn;
/**
* 冒泡排序和选择排序
* @author cz
*
*/
public class Test4 {
public static void main(String[] args) {
int[] array={1,32,23,11,67,9};
bubbleSort(array);
selectSort(array);
for(int x:array){
System.out.println(x);
}
}
public static void bubbleSort(int[] array) {
// TODO Auto-generated method stub
for(int x=0;x<array.length;x++){
for(int y=0;y<array.length-x-1;y++){
if(array[y]>array[y+1]){
int temp=array[y];
array[y]=array[y+1];
array[y+1]=temp;
}
}
}
}
public static void selectSort(int[] array) {
// TODO Auto-generated method stub
for(int x=0;x<array.length;x++){
for(int y=x+1;y<array.length;y++){
if(array[x]>array[y]){
int temp=array[x];
array[x]=array[y];
array[y]=temp;
}
}
}
}
}

复制代码

4、二维数组遍历

package cn;
/**
* 二维数组的遍历。
* 公司年销售额求和
* 某公司按照季度和月份统计的数据如下：单位(万元)
* 第一季度：22,66,44
* 第二季度：77,33,88
* 第三季度：25,45,65
* 第四季度：11,66,99
*杨辉三角。
*1
*1 1
*1 2 1
*1 3 3 1
*1 4 6 4 1
*1 5 10105 1
* @author cz
*
*/
public class Array2 {
public static void main(String[] args) {
int[][] arr = new int[][] { { 1, 3, 5 }, { 2, 4, 6 } };
getArray(arr);
// getArr2(6);
}
public static void getArray(int[][] arr) {
// TODO Auto-generated method stub
// int sum = 0;
for (int[] array : arr) {
for (int x : array) {
System.out.println(x);
// sum += x;
}
}
for (int x = 0; x < arr.length; x++) {
for (int y = 0; y < arr[x].length; y++) {
if (arr[x][y] == 0) {
break;
}
System.out.print(arr[x][y] + "\t");
}
System.out.println();
}
// System.out.println(sum);
}
public static void getArr2(int n) {
int[][] arr = new int[n][n];
for (int x = 0; x < arr.length; x++) {
arr[x][0] = 1;
arr[x][x] = 1;
}
for (int x = 2; x < arr.length; x++) {
for (int y = 1; y <= x - 1; y++) {
arr[x][y] = arr[x - 1][y] + arr[x - 1][y - 1];
}
}
getArray(arr);
}
}

复制代码

作者: 只想好好的 时间: 2015-5-13 12:02
笔记内容：数组及数组内存的划分
笔记来源：毕向东JavaSE基础视频05，（我下载的视频上面是这样的，没有第几天）
正文：我的全写在代码里

package cxw.study.one;
import org.junit.Test;
public class Array {
/*
* 内存的划分：
* 寄存器
* 本地方法区
* 方法区
* 栈内存
* 存储的都是局部变量
* 而且变量所属的作用域一旦结束，该变量就自动释放
* 堆内存
* 存储是数组和对象(其实数组就是对象) 凡是new建立在堆中
* 特点：
* 1.每一个实体都有首地址值
* 2.堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同，
* 整数是0，小数是0.0或者0.0f boolean false char '\u0000'
* 3.垃圾回收机制
*/
/**
* 折半查找
* 二分查找法
*/
@Test
public void halfSearch(){
int[] array = {11, 13, 15, 19, 28, 33, 45, 78, 106};
int index = 0;
int key = 11;
int max, min, mid;
min = 0;
max = array.length;
mid = (min + max) / 2;
while(array[mid] != key){
if(key > array[mid]){
min = mid + 1;
} else if(key < array[mid]){
max = mid - 1;
}
if(max < min){
index = -1;
System.out.println( key + "的下标为：" + index);
break;
}
mid = (max + min) / 2;
}
if(index != -1){
index = mid;
System.out.println( key + "的下标为：" + index);
}
}
/*
冒泡排序：基本思想是每次进行相邻的两个数对比a(i)>a(i+1)，然后将两个数交换
int[] array = { 34, 19, 11, 109, 3, 56, 1, 99, 123, 112, 564 };
排序的步骤：
第1步[19, 11, 34, 3, 56, 1, 99, 109, 112, 123, 564]
第2步[11, 19, 3, 34, 1, 56, 99, 109, 112, 123, 564]
第3步[11, 3, 19, 1, 34, 56, 99, 109, 112, 123, 564]
第4步[3, 11, 1, 19, 34, 56, 99, 109, 112, 123, 564]
第5步[3, 1, 11, 19, 34, 56, 99, 109, 112, 123, 564]
第6步[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
第7步[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
第8步[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
第9步[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
第10步[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
所以最终的结果为
[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
*/
@Test
public void bubbleSort(){
int[] array = { 34, 19, 11, 109, 3, 56, 1, 99, 123, 112, 564 };
System.out.println("原数组：");
printArray(array);
for(int i = 0; i < array.length - 1; i++){
for(int j = 0; j < array.length - 1 - i; j++){
if(array[j] > array[j+1]){
int temp = array[j];
array[j] = array [j+1];
array[j+1] = temp;
}
}
printArray(array);
}
// printArray(array);
}
/*
选择排序:基本思想是每次循环将此次循环的最值放到后面
int[] array = { 34, 19, 11, 109, 3, 56, 1, 99, 123, 112, 564 };
步骤如下：
第1步 [1, 34, 19, 109, 11, 56, 3, 99, 123, 112, 564]
第2步 [1, 3, 34, 109, 19, 56, 11, 99, 123, 112, 564]
第3步 [1, 3, 11, 109, 34, 56, 19, 99, 123, 112, 564]
第4步 [1, 3, 11, 19, 109, 56, 34, 99, 123, 112, 564]
第5步 [1, 3, 11, 19, 34, 109, 56, 99, 123, 112, 564]
第6步 [1, 3, 11, 19, 34, 56, 109, 99, 123, 112, 564]
第7步 [1, 3, 11, 19, 34, 56, 99, 109, 123, 112, 564]
第8步 [1, 3, 11, 19, 34, 56, 99, 109, 123, 112, 564]
第9步 [1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
第10步[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
所以最终的结果为
[1, 3, 11, 19, 34, 56, 99, 109, 112, 123, 564]
*/
@Test
public void selectSort() {
int[] array = { 34, 19, 11, 109, 3, 56, 1, 99, 123, 112, 564 };
System.out.println("原数组：");
printArray(array);
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
printArray(array);
}
//printArray(array);
}
/**
* 遍历数组
*
* @param array
*/
public void printArray(int[] array) {
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i != array.length - 1) {
System.out.print(array[i] + ", ");
} else {
System.out.println(array[i] + "]");
}
}
}
/**
* 折半查找
* 二分查找法
*/
@Test
public void halfSearch_2(){
int[] array = {13, 15, 19, 28, 33, 45, 78, 106};
int index = -1;
int key = 33; //要查找的数
int max, min, mid;
min = 0;
max = array.length;
while(min <= max){
mid = (max + min) / 2;
if(array[mid] == key){
index = mid;
System.out.println( key + "的下标为：" + index);
break;
}
if(key > array[mid]){
min = mid + 1;
} else if(key < array[mid]){
max = mid - 1;
}
}
if(index == -1){
System.out.println( key + "的下标为：" + index);
}
}
}

复制代码

作者: anywayDo 时间: 2015-5-13 18:21

anywayDo 发表于 2015-5-13 00:08
笔记内容：数组
笔记来源：毕向东Java基础视频第4天
正文：

恩恩。。排版的话，因为是word做的笔记，所以比较凌乱。。见谅哈。

作者: 李工 时间: 2015-5-13 19:27
本帖最后由李工于 2015-5-14 07:40 编辑

笔记内容：数组与二维数组

笔记来源：毕向东Java基础视频第4天

正文：

******************************************** 数组 **********************************************

【定义】：数组本质上是多个同类型数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。

【使用方法】：

声明和创建：
方法一：
         type[] 数组名 = new type[数组中元素的个数];
         比如：
         int[] a = new int[10];
      方法二：
         type[] 数组名 = new type[]{逗号分隔的初始化值};
　　       比如：
　　       int[] a = {1,2,3,4};
　　       int[] a = new int[]{1,2,3,4};

  数组元素的引用：
      arrayName[index]
      其中index为数组下标，它可以为整型常数或表达式。如a[3]，b(i为
      整型)，c[6*i]等。下标从0开始，一直到数组的长度减1。数组元素的下
      标从0开始；长度为n的数组的合法下标取值范围为：0~n-1;
数组的长度：
      arrayName.length的值即为数组的长度。

输出一个数组：

int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray); //Arrays.toString代表将数组转化为字符串
System.out.println(intArrayString);
//结果为 [1, 2, 3, 4, 5]

复制代码

移除一个数组：

int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3); //将原数组进行元素删除操作并将结果赋值给一个新数组
System.out.println(Arrays.toString(removed));

复制代码

数组的升序排列：

import java.util.Arrays;
public class ArraysSort {
public static void main(String args[]){
int[] a={1,4,-1,5,0};
Arrays.sort(a); //数组a[]的内容变为{-1,0,1,4,5}
for(int i=0;i<a.length;i++)
System.out.println(a[i);
}
}

复制代码

数组的复制算法：

public class ArraysCopy {

复制代码

【二维数组】：二维数组的定义：
　　type arrayName[ ][ ];
　　type [ ][ ]arrayName;
二维数组的初始化：
1.静态初始化
int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};
Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。

2.动态初始化
1) 直接为每一维分配空间，格式如下：
arrayName = new type[arrayLength1][arrayLength2];
int a[ ][ ] = new int[2][3]；

3) 例：
二维简单数据类型数组的动态初始化如下：
int a[ ][ ] = new int[2][ ]；
a[0] = new int[3];
a[1] = new int[5];
对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。而且，必须为每个数组元素单独分配空间。例如：
String s[ ][ ] = new String[2][ ];
s[0]= new String[2];//为最高维分配引用空间
s[1]= new String[2]; //为最高维分配引用空间
s[0][0]= new String("Good");// 为每个数组元素单独分配空间
s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
s[1][0]= new String("to");// 为每个数组元素单独分配空间
s[1][1]= new String("You");// 为每个数组元素单独分配空间

二维数组元素的引用：
对二维数组中的每个元素，引用方式为：
arrayName[index1][index2]

【冒泡排序】：

public class BubbleSort {
public static void main(String[] args){
int[] arr={1,4,3,7,14,9,66,33,20,122,65,76};
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1;j++){
if(arr[j]<arr[j+1]){
int t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}

复制代码

作者: V_nan 时间: 2015-5-13 22:01
本帖最后由 V_nan 于 2015-5-15 21:45 编辑

笔记内容：数组的重要点
         笔记来源：毕向东Java基础视频第4天正文：
-------------------------------------------------------
数组的理解：
数组的基本解释：数组本身是一种引用类型，一个数组定义好后，数组长度和存储空间是不变的。
数组的定义格式： a:  int[] arr
                           b: int arr[]    这两种方法定义格式推荐使用a，a定义格式阅读性强，b的话跟定义变量的形式有点相似，容易混淆
数组的初始化：数组的初始化分两种方式，一种为静态初始化，直接将数组中的元素列举出来 int[] arr = {1,5,6,2,......};
                        一种为动态初始化，只定义数组的长度，初始化值使用系统的默认初始化值  int[] arr = new int[length];
                        这里的默认初始化值：整数类型的默认初始化值为0，浮点类型的为0.0，字符类型为'\u0000',布尔类型为false，引用类型为null
数组的使用：数组的使用也可以说是对数组角标的操作吧(当然这句话是不对的···)，数组索引是从0开始的到length-1，超出其中的值会编译失败
                  提示数组角标越界。数组是一个实体，所以存储在堆内存中，具体怎么的就描述不出来了，只会用，不会说。
数组的一些操作：选择排序，冒泡排序，折半查找，等等的在Java提供的Array类中的static修饰的方法，可以创建对象调用方法，代码就不发了···
               来上基础班的时候把自学的代码都删除掉了从头开始写起，现在刚上完循环，还没接触到数组，就先不写了，如果需要的话明天补上今天终于学完数组了，补上代码求分啊
      自己弄的个工具类，文档注释不熟，求教版主，最后两个方法的return注释要怎么写？

································································································································································································

/**
* 本类是数组的工具类,包含：选择排序,冒泡排序,获取数组元素索引,获取数组最大值等等功能。
* @author 0508
* @version 1.0
*/
public class ArrayTool
{
/**
* 这个方法是用来给给定数组进行排序:将数组中的元素从小到大排序。
* @param arr int类型的数组。
*/
public static void selectSort(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=x+1;y<arr.length;y++)
{
temp(arr,x,y);
}
}
}
/**
* 这个方法是用来给给定数组进行排序:将数组中的元素从小到大排序。
* @param arr int类型的数组。
*/
public static void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
temp(arr,y,y+1);
}
}
}
/**
* 这个方法是用来给给定数组中指定的两个索引中的元素进行互换。
* @param arr int类型的数组。
* @param x int类型的整数。
* @param y int类型的整数。
*/
public static void temp(int[] arr,int x,int y)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
/**
* 该方法用于获取给定数组中的元素中的最大值。
* @param arr int类型的数组。
* @return arr[maxIndex] 返回一个int类型的整数。
*/
public static int getMax(int[] arr)
{
int maxIndex = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[maxIndex])
{
maxIndex = x;
}
}
return arr[maxIndex];
}
/**
* 该方法用于获取给定数组中的元素中的最大值的索引
* @param arr int类型的数组。
* @return maxIndex 返回一个int类型的整数。
*/
public static int getMaxIndex(int[] arr)
{
int maxIndex = 0;
for(int x=0;x<arr.length;x++)
{
if(arr[x]>arr[maxIndex])
{
maxIndex = x;
}
}
return maxIndex;
}
/**
* 该方法用于打印给定的数组。
* @param arr int类型的数组。
*/
public static void printArr(int[] arr)
{
System.out.print("arr={");
for(int x=0;x<arr.length;x++)
{
if(x == arr.length-1)
{
System.out.println(arr[x]+"}");
}
else
{
System.out.print(arr[x]+",");
}
}
}
/**
* 该方法用于获取给定数值在给定数组中出现的索引
* @param arr int类型的数组。
* @param key int类型的整数。
* @return -1 返回-1表示输入的数值有误。
* @return x 返回一个int类型的整数。
*/
public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x] == key)
{
return x;
}
}
return -1;
}
/**
* 该方法用于获取给定数值在给定数组中出现的索引
* @param arr int类型的数组。
* @param key int类型的整数。
* @return -1 返回-1表示输入的数值有误。
* @return mid 返回一个int类型的整数。
*/
public static int getIndex_(int[] arr,int key)
{
int min = 0;
int max = arr.length-1;
int mid = (min+max)/2;
for(int x=0;x<arr.length;x++)
{
if(arr[mid] == key)
return mid;
else if(arr[mid]>key)
max = mid-1;
else
min = mid+1;
if(max<min)
return -1;
mid = (min+max)/2;
}
return mid;
}
}

复制代码

····················································································
二维数组:
概念：可以看成是一个一维数组不过其中的元素也是数组
定义格式：int[][] arr = new int[n][m]//n可以看成是行数，即有n个一维数组，m可以看成是列数，即每个一维数组中有m个数组元素
int[][] arr = new int[n][]//每个一维数组中的元素不确定，可以自己定义
int[][] arr = {{},{},{},······}//习惯称这个为列举法···
附一个题目，跟自己写的代码，可能很繁琐，自己优化不来了

/*
0 1 2 3 4
1 2 3 4 5 0
16 17 18 19 6 1
15 24 25 20 7 2
14 23 22 21 8 3
13 12 11 10 9 4
*/
import java.util.Scanner;
class Test4
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println("请输入需要打印的反螺旋矩阵的行数");
while(true)
{
int size = sc.nextInt();
int[][] arr = new int[size][size];
int n=size,k=0;
int m = (n+1)/2;
for (int i=0;i<n;i++)
{
for(int j=i;j<=n-1-i;j++)
arr[i][j] = ++k;
for(int j=i+1;j<=n-1-i;j++)
arr[j][n-i-1] = ++k;
for(int j=i;j<n-1-i;j++)
arr[n-1-i][n-2-j] = ++k;
for(int j=i+1;j<n-i-1;j++)
arr[n-j-1][i] = ++k;
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
System.out.print(arr[i][j] + "\t");
System.out.println("");
}
}
}
}

复制代码

作者: V_nan 时间: 2015-5-13 22:03

V_nan 发表于 2015-5-13 22:01
笔记内容：数组的重要点
笔记来源：毕向东Java基础视频第4天
正文：

晕倒，更新漏洞卡了一下，直接回复了····版主，咋办，能重写吗？

作者: 猿-动力 时间: 2015-5-13 22:24
记内容：数组（静态初始化-常见问题）
      笔记来源：毕向东Java基础视频第四天
      正文：

第一种定义格式：（数据不明确）
int[] arr =new int[2];//还是这样写比较好。
Arr[0] = 90;
Arr[1] = 80;

也可以这样写
int arr[]=new int[2];

第二种定义格式：（数据明确时用）
int[]  arr = new int[]{3,1,6,5,4};//静态的初始化方式，很直观的能看里面的元素。
            注意：能在内存中开辟空间，但一定不要中括号里写内容，容易出错。
也可以这样写
int[] arr ={3,1,6,5,4};//是一种简化方式。

数组在操作中常见问题：(掌握)
int[] arr = new int[3];
System.out.println(arr[3]);
   注意：角标是从零开始的[0][1][2].
         编译时不报错，只检查语法有错误没。
         只有运行时在内存中开辟空间，发现不存在，这时就该报错了。
         (ArryIdexOutOfBoundsException： 3 ：//数组角标异常越界：访问到了数组中不存在的角标。)

  int[] arr = new int[3];
  arr = null;  //不具备任何实体。
  System.out.println(arr[1]);
            编译时不报错，只检查语法有错误没。
            (NullPointerException:空指针异常：当引用没有任何指向值null的情况，该引用还在于操作实体。)

作者: zww594509950 时间: 2015-5-15 18:42
笔记内容：数组的几个重要练习
笔记来源：毕向东Java基础视频第4天；
正文：
在学习毕老师的数组的这一部分的知识时，个人觉得老师在课上讲的那几个数组的练习非常重要，不仅对算法思想有较高的提高，而且对之后的课程学习都有很大的帮助。
一、获取最值（以最大值为例）思路：
1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。通过一个变量进行临储。
2，让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该该变量记录较大值。
3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

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

复制代码

二、数组排序（选择排序和冒泡排序）
1，选择排序，将元素与之后的所有元素比较，用到循环，第一圈最值出现在首元素位置，以此类推。

public static void selectSort(int[] arr){
for (int x=0; x<arr.length-1 ; 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;
}
}
}
}

复制代码

2，冒泡排序，相邻的两个元素进行比较，如果符合条件换位。第一圈最值出现在最后一位。

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：避免角标越界。*/{
if(arr[y]<arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}

复制代码

当然，位置互换位置是可以单独封装的，此处先不表。
三、数组反转。（根据角标，首尾相换，首元素递增，尾元素递减，角标条件判断很关键）

public static void reverseArray(int[] arr){
//start和end的判断是重点
for(int start=0,end=arr.length-1; start<end ; start++,end--){
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}

复制代码

四、数组查找（普通查找和这般查找）
普通查找，对数组遍历，获取要查找的数的位置，如果没有返回-1

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 int halfSearch(int[] arr,int key){
int min = 0,max = arr.length-1,mid;
while(min<=max){
mid = (max+min)>>1;
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}

复制代码

五、利用数组进行进制转换（利用查表法进行十进制转换十六进制）
查表法：将所有的元素临时存储起来。建立对应关系。

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){
//每一次&15后的值作为索引去查建立好的表。就可以找对应的元素。
int temp = num & 15;
arr[--pos] = chs[temp];
num = num >>> 4;
}
//存储数据的arr数组遍历。
for(int x=pos;x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}

复制代码

虽然有了对象之后可以对上述的各种功能直接进行调用，但对上述的理解练习有利于加强对算法的提高，及时学习了面向对象，但算法依然不能忽视！

作者: urankwong 时间: 2015-5-15 21:08
本帖最后由 urankwong 于 2015-5-15 21:12 编辑

笔记内容：数组
笔记来源：刘然 java基础视频第5天
里面有些错别字，请忽略
******************我***是***分***割***线************************
数组：
      1,2,3,4,5
      概述：存储多个同一种类型的元素的容器。
      好处：可以对数组中的元素进行编号，从0开始。方便我们来操作。
      数组的定义格式：
            元素类型[] 数组名 = new 元素类型[数组的长度或者元素个数];
            new：申请内存空间。
            int[] arr = new int[5];
      怎么获取数组中的元素？
            第一个：arr[0];
                              arr[1];
                              arr[2];
      内存的一个划分：
            栈：存的是局部变量。
                     局部变量：定义在方法中或者方法的形式参数上的变量。
                     当变量使用完毕后（超出了变量的作用域），直接从内存消失。
            堆：存的是new出来的东西（实体）。
                     1、每一个实体都有地址值。
                     2、每一个实体都有默认值。
                              整数：0
                              小数：0.0
                              字符：'\u0000'
                              布尔：false；
                     3、在不确定的时间被垃圾回收器（GC）给回收调。
            方法区：方法，String常量池，静态区，byte常量池。
            了解：
                     本地方法区：和系统相关的内容。
                     寄存器：有CPU来分配资源的。
      定义数组的四种方式：此处以int类型举例
            A： int[] arr = new int[5]; //定义一个int类型的数组，arr。
            B： int arr[] = new int[5]; //定义一个int类型的arr数组。
            C： int[] arr = new int[]{1,2,3,4,5};
            D:       int[] arr = {1,2,3,4,5};
                     arr[0],arr[2]
      推荐使用：
            A，D

数组的常见操作：
      数组的长度：数组名.length
            长度：从1-数组名.length
            索引： length - 1;
      数组的遍历；

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

复制代码

      数组的求最大值：

/**1、定义一个变量max记录最大值。
2、遍历数组，拿到每一个元素，然后依次来跟最大值比较。
如果遍历到的元素，比最大值大，把该元素的值赋值给max。
3、将最大值返回。
*/
int[] arr = {1,2,3,4,5};
int max = arr[0]; //我们假设数组中的第一个元素是最大值。
for(int x=0;x<arr.length;x++)
{
//arr[x]就是数组中的元素
if(arr[x]>max) //判断当前遍历到的元素是否比最大值大，
//如果比最大值还大，就将该值赋值给max
{
max = arr[x];
}
}
System.out.println(max); //输出最大值。

复制代码

数组的基本查找功能：

/** 1、定义一个变量记录要查找的值。 key
2、遍历数组，拿到每一个元素，然后依次来跟key比较。
如果相等，即返回该元素的索引（小标，下标）。
如果不相等，返回-1;
*/
int[] arr = {1,2,3,8,4,5,8};
int key = 8;
//int index = -1; //记录的就是我要找的key在数组中的索引
//int[] arrIndex = new int[arr.length];
for(int x=0;x<arr.length;x++)
{
//arr[x]就是数组中的元素
if(arr[x]==key)
{
index = x;
break;
//arrIndex[x] = x;
}
}

复制代码

二维数组：
      概述：就是每个元素都是一维数组的数组。
      A：int[][] arr = new int[n][m];
            n:可以看做是行。代表arr这个二维数组有多少个一维数组。
            m:可以看做是列。代表每一个一维数组中有多少个元素。
      B：int[][] arr = new int[n][];
            n:可以看做是行。代表arr这个二维数组有多少个一维数组。
            第二个中括号的意思是：每个一维数组的长度不固定。
      C：int[][] arr = { {1,2,3},{4,5},{7,8,9}};

遍历：
      二维数组的长度：
            arr.length
      每个一维数组的长度：
            arr[x].length
      每个二维数组的元素：
            arr[x][y]
应用：
      计算商场的年销售额。

作者: V_nan 时间: 2015-5-15 21:46
版主，补完自己总结的了，求打赏

作者: 791008594 时间: 2015-5-15 23:42
本帖最后由 791008594 于 2015-5-15 23:49 编辑

笔记内容：数组

笔记来源：毕向东java基础视频第5天

正文：

一、数组定义

1，什么是数组：数组是存储同一种类型的多个元素的容器。

2，数组的优点：存入数组的元素是有序的，所有元素从存入开始都会从0开始分配空间，方便我们获取；

二、数组格式的定义及初始化的方法：

定义方式1：

数据类型[] 数组名；（推荐使用的标准格式）

初始化方式1.1(例)：int[] arr = new int[5];

初始化方式1.2(例)：int[] arr = new int[]{1,2,3,4,5};

初始化方式1.3(例)：int[] arr = {1,2,3,4,5};

定义方式2：

数据类型数组名[]；（不推荐使用此格式）

初始化方式2.1(例)：int arr[] = new int[5];

初始化方式2.2(例)：int arr[] = new int[]{1,2,3,4,5};

初始化方式2.3(例)：int arr[] = {1,2,3,4,5};

三、数组在java的内存图：

详细见图5-1：

四、常见操作及举例：

1，数组的赋值

举例：1，arr[0]=10;

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

3，int[] arr = {1,2,3,4,5};

2，获取数组的长度

例如：arr.length

3，数组的遍历

int[] arr={12,34,45,76};

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

int j = arr;

System.out.println(j);

}

4，获取最值

//传入一个数组

public staticint getMax(int[] arr){

//定义变量记录最大值

int max = 0;

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

if(arr[x]>max)

max= arr[x];

}

return max;//返回一个最值

}

5，数组元素所在位置的查找

//传入两个参数，一个基本类型参数一个引用类型参数

public staticint getIndex(int[] arr,int index){

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

if(arr[x]==index)

index= x;

}

return index;

}

6，修改数组中指定索引处的值

//传入两个参数，一个基本类型参数一个引用类型参数

public static booleanreviseNumber(int[] arr,int index){

boolean flag = false；

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

if(arr[x]==index)

flag = true；

returnflag;

}

return flag;

}

五、二维数组：

二维数组：

第一个中括号代表行存储的是第二维数组的地址值，第二个中括号代表列存储的是实际数据；

详细见图5-2：

定义及赋值的格式：

举例：

A:int[][] arr = new int[2][3];

B:int[][] arr = new int[4][];

C:int[][] arr = {{1,2,3},{4,5},{9}};

输出操作：

举例：

int[][] arr ={{1,2,3},{4,5},{9,10,11}};

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

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

int number = arr[j];

System.out.println(number);

}

作者: 791008594 时间: 2015-5-15 23:52
非常对不起大家，图片调了很多次还是没调好，点进去应该可以看清楚，整理了1个小时左右，希望可以拿到技术分，因为我的分实在太低了，求版主大人打赏！！嘿嘿~~

作者: 汤姆大叔 时间: 2015-5-16 04:08
笔记内容：数组
      笔记来源：毕向东Java基础视频第4天
      正文：
一：数组的定义：同一种类型数据的集合。其实数组就是一个容器。
      格式1：元素类型[] 数组名 = new 元素类型[元素长度或数组个数]；
         实例：int[] arr = new int[5];
      格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素，元素……};
         示例：int[] arr = new int[]{2,4,7,5};
               int[] arr = {6,3,8,9};
二：内存结构：栈内存，堆内存，方法区，本地方法区，寄存器。
      栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
      堆内存：1.数组和对象，通过new建立的实例都存放在堆内存中。
                     2.每一个实体都有内存地址值。
                     3.实体中的变量都有默认初始化值 (int:0 , double:0.0 , floot:0.0f  boolean:false)
                     4.实体不在被使用，会在不确定的时间内被垃圾回收器回收。

         垃圾回收机制：数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个                               不确定的时间被垃圾回收器释放掉。
三：静态初始化，常见问题.
         int[ ] arr = 和 int  arr[ ]    两种书写方式都正确。
         int[ ] arr = new int[ ]{3,7,4,8}  此时 [ ]中尽量不要写长度
         数组脚标越界异常(ArrayIndexOutOfBoundsException)：
         int [ ] arr = new int [ 3 ];
         System.out.println(arr[3]);    可以编译成功，但是运行失败。  因为运行的时候，才会在堆内存中开辟空间
         操作数组时，访问到了数组中不存在的角标。
         空指针异常(NullPointerException)：
         int[ ]  arr = null;
         System.out.println(arr[1]);
         arr引用没有指向实体，却在操作实体中的元素时。
四：遍历

class ArrayDemo3
{ public static void main(String[] args)
{
//数组的操作
//获取数组的元素，通常会用到遍历
int arr[] = {9,4,56,19,7,5};
printArray(arr);
}
// 定义一个功能：用于打印数组的元素。元素间用逗号隔开 1。没有结果因为打印了用void 2.有未知元素参与
//数组中有一个元素可以直接获取数组的个数或者长度。 .length
//int num = 0;
//使用方式；数组名称.length =
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
//if(x<arr.length-1)
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}

复制代码

需要注意的地方：

System.out.println(arr);
显示：[I@de6ced
[ = 数组
I = int
de6ced = 数组内存存放地址由哈希算法算出来的哈希值，十六进制数

复制代码

五：获取最值：

/*
给定一个数组 {3,5,1,7,9,6} 打印出数组中的最大值
*/
class ArrayTest
{
public static void main(String[] args)
{
int[] arr = new int[]{3,5,1,7,9,6};
double[] arrd = new double[]{5.4,6.9,8.8,2.6,5.1};
int max = getMax(arr);
double maxd = getMax(arrd);
System.out.println("Max = "+max);
System.out.println("Max = "+maxd);
}
/*
给定一个数组 {3,5,1,7,9,6} 打印出数组中的最大值
步骤：
1，定义一个函数，遍历数组，先定义一个变量，赋值，可以为数组中的任何一个数值
2，其他数组值和改值进行比较，然后如果比该值大，那么就赋值给这个变量。
3，在主函数中调用这个函数，打印输出。
定义函数：
1.判断函数是否有返回值：有，返回int类型。
2.是否有未知参数：有，函数需要接受数组。定义参数类型为 int[]
*/
//第一种方法。
//第二种方法：临时变量可以初值化为0吗？答案是可以的，因为数组中的每一个元素都对应一个标号。
//所以用临时变量储存标号即可。
public static int getMax(int[] arr)
{
// int max = arr[0];
int max = 0;
for(int x=1;x<arr.length;x++)
{
// if(max<arr[x])
// {
// max = arr[x];
// }
if(arr[max]<arr[x])
{
max = x;
}
}
return arr[max];
}
//利用第二种方法，求出double类型的数组的最大值。
//此时我们可以定义一个同名但是有不同参数类型的 getMax进行重载操作
// 我们假设给定的数组为{5.4,6.9,8.8,2.6,5.1}
public static double getMax(double[] arr)
{
int max = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[max]<arr[x])
{
arr[max] = arr[x];
}
}
return arr[max];
}
}

复制代码

六：选择排序和冒泡排序：

import java.util.*;
/*
选择排序 {8,5,1,9,4,7}
给定数组，按照从小大的顺序排列。
*/
class ArrayTest2
{
public static void main(String[] args)
{
int[] arr = new int[]{8,5,1,9,4,7};
//排序前
printArray(arr);
//选择排序
// selectSort(arr);
//冒泡排序
bubbleSort(arr);
//排序后
printArray(arr);
//java中已经定义好的一种排序方式，开发中，对数组排序，要使用该局代码
Arrays.sort(arr);
}
//冒泡排序
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]>arr[y+1])
{
/*
int temp = arr[y+1];
arr[y+1] = arr[y];
arr[y] = temp;
*/
swap(arr,y,y+1);
}
}
}
}
//选择排序
//内循环结束一次，最值出现在头角标位置上。
public static void selectSort(int[] arr)
{
for (int x = 0;x<arr.length-1 ;x++ )
{
for (int y=x;y<arr.length-1 ;y++ )
{
if (arr[x]>arr[y+1])
{
// int temp = arr[x];
// arr[x] = arr[y+1];
// arr[y+1] = temp;
swap(arr,x,y+1); //自己在操作中误写成 swap(int[] arr,int x,int y+1); 需要注意
}
}
}
}
//不论什么排序都需要对满足条件的元素进行位置的置换，所以可以将这部分代码单独的提取出来。单独封装成一个函数。
//该函数中应该有3个未知函数，因为在获取角标的前提是，先要确定数组。所以，需要定义三个参数， int[] arr,int a ,int b
//置换功能
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = 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]+" ]");
}
}
}

复制代码

七：折半查找

/*
折半查找
数组 {3,8,9,16,20,35}
折半查找数组必须是有序的
*/
class ArrayTest4
{
public static void main(String[] args)
{
//查找 20在元素中的位置
int[] arr = new int[]{3,8,9,16,20,35};
// int index = getIndex(arr,35);
// int index = halfSearch(arr,35);
int index = halfSearch_2(arr,35);
System.out.println("index = "+index);
}
/*
步骤：
1，定义3个变量，记录每次比较实际的最大值，最小值和中间值的角标。max min mid
2，遍历数组，
3，使用mid的值，于需要查找的值比较，判断大小。
4，比较完大小之后，重新定义所查找的范围。使用循环语句，继续比较，知道查到改值。
5，如果改值不存在，那么返回 -1。
定义一个函数，方便该功能的复用性。
1，因为是返回数组中数值的角标，所以返回值类型为int
2，因为是查找某一数值，同时数组不确定，所以又两个参数， int[] arr,int x
*/
//折半查找
public static int halfSearch(int[] arr,int key)
{
int max = arr.length-1;
int min = 0;
int mid = (max+min)/2;
while(key!=arr[mid]) //写代码过程中，误将arr[mid]写成 mid ！！！！！
{
if(key<arr[mid])
max = mid-1;
else if(key>arr[mid])
min = mid+1;
if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}
//折半查找的第二种方法。
public static int halfSearch_2(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
while (min<max) //第一次书写，min<max 正确写法是 min<=max 需要注意。
{
mid = (min+max)>>>1;
if (key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
//数组查找，给定一个数组，判断在数组中的位置
public static int getIndex(int[] arr,int key)
{
for (int x=0;x<arr.length ;x++ ) //书写代码过程中，误将arr.length写成arr.length-1 ！！！！！
{
if (key==arr[x])
{
return x;
}
}
return -1;
}
}

复制代码

由于字数限制，分为两个来发帖了

作者: 汤姆大叔 时间: 2015-5-16 04:10
八：查表法二进制终结版本：

class ArrayTest7
{
public static void main(String[] args)
{
toBin(0);
toOct(60);
toHex(-60);
}
//十进制转二进制
public static void toBin(int num)
{
trans(num,1,1);
}
//十进制转八进制
public static void toOct(int num)
{
trans(num,7,3);
}
//十进制转十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
//代码功能的提取。
public static void trans(int num,int base,int offset)
{
//如果给的数值为0 的话，那么整个函数就停止运转
//所以要对0进行判断
if (num == 0)
{
System.out.println(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]);
}
System.out.println();
}
}

复制代码

九：二维数组：数组中的数组。
格式：
格式1：int[ ][ ] arr = new int[3][4];

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有4个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 56;

               格式2：int[][] arr = new int[3][];

                  二维数组中有3个一维数组
                  每个一维数组都是默认初始化值null
                  可以对这个三个一维数组分别进行初始化
                  arr[0] = new int[3];
                  arr[1] = new int[4];
                  arr[2] = new int[5];
               格式3：int[][] arr = {{3,8,2,6},{2,7,8,3},{9,0,1,6}};
      联系：一个公司有3个小组，求该公司一年中，所有小组，4个季度的业绩综合。

class ArrayTest8
{
public static void main(String[] args)
{
int[][] arr ={{3,2,5,7},{9,1,6,3},{6,6,4,3}};
int sum = getSum(arr);
System.out.println("该公司3个小组，4个季度的业绩综合为 = " +sum);
}
//定义一个功能。计算该公司 3个小组，4个季度的业绩综合。
public static int getSum(int[][] arr)
{
int sum = 0;
for (int x=0;x<arr.length ;x++ )
{
for (int y=0;y<arr[x].length ;y++ )
{
sum += arr[x][y]; //书写过程中，写成arr[y],错误提醒，数组类型不能和int类型相加，顿悟。改为arr[x][y]
}
}
return sum; //书写过程中忘记写返回语句
}
}

复制代码

         注意 int[ ][ ] arr = new int[2][3];
                  System.out.println(arr);    ------->输出结果为 [[@de6ced
                  System.out.println(arr[0]); ------>输出结果为 [[@de7eca    要注意都是内存地址值
                     int[][]  arr = new int[3][];
                     System.out.println(arr);    ------->输出结果为 [[@de6ced
                     System.out.println(arr[0]); ------->输出结果为 null
                  数组为引用数据类型，没有初始化，默认初始化值为 null

作者: 麦兜是个猪 时间: 2015-6-5 11:16
本帖最后由麦兜是个猪于 2015-6-5 11:21 编辑

笔记内容：数组
笔记来源：毕向东java基础第4天
一维数组

概念：数组就是存储同一种数据类型的集合，是一个容器，它可以对容器内的数据从0开始，进行编号，用于封装这些数据，是一个实体。

格式：

元素类型[] 数组名 = new 元素类型[元素个数或者数组的长度]；

元素类型[] 数组名 = {元素1，元素2......}；

数组其实还有其他的形式，但上面两种最常用，对于其他格式，这里不在赘述。

引入两个内存的知识点：栈内存和堆内存。

栈内存：存储局部变量，数据使用完毕后，会自动释放。

堆内存：内存每一个实体，数组和对象都在对内存中。

堆内存的特点：1，内存地址值；

2，默认初始化值，int：0，float型：0.0f，double型：0.0，

boolean型：false；

3，垃圾回收机制：不定时自动回收。

二维数组

概念：

其实就是将数组作为元素存到数组当中，构成的数组称为二维数组。

格式：

格式一：int[][] arr= new int[5][6];

代表这个数组中有5个一维数组，每一个一位数组中有6个元素，我们要表示某一个元素在数组中的位置可以写成：arr[0][1]，这代表的是0角标上的一维数组1角标上的元素。

格式二：int[][] arr= new int[5][];

格式三：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

格式三是直接把一维数组中的元素都初始化了。

数组中的常见操作

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

数组中有一个属性，可以直接获取到数组中的元素个数：length，使用方式：数组名称.length。

但凡有数组通常都会用到for循环。

下面是对着数组进行遍历的代码：

class ArrayDemo
{
public static void main(String[] args)
{
int[] arr ={2,3,4,5,6,6,7,8,9,88};
printArray(arr);//打印出来的结果是[2,3,4,5,6,6,7,8,9,88]。
}
//定义功能用于打印数组中的元素。元素间用逗号隔开。
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]+"]");//这是最后一个元素。
}
System.out.println();//换行。
}
}

复制代码

为了代码看着清晰以下的内容，思路都会写在外边。

获取数组中的最大值和最小值：

获取最值需要进行比较。每一比较都会有一个较大或者较小的值，因为该值不确定，可以通过一个变量进行临时存储让数组中的每一个元素都和这个值进行比较，当我们要获取最大值时，如果在数组中遍历到的值大于变量中的值，就用改变量记录较大的值；当所有的元素都比较完成，变量中存储的就是数组中的最大值，获取最小值同理。

其实我们将这个变量定义成数组的一个角标，或者这个角标上所对应的值都可以，我选择其中一种方法，直接将变量定义成数组0角标上的值。

/*
需求：获取数组中的最大最小值
*/
class ArrayDemo2
{
public static void main(String[] args)
{
int[] arr ={2,1,3,6,4,7,9,6};
int max = getMax(arr);
int min = getMin(arr);
System.out.println("min="+min);
System.out.println("max="+max);
}
public static int getMax(int[] arr)
{
int max = arr[0];//定义一个变量，并将数组中0角标的值赋给这个变量。
for(int x = 1;x<arr.length;x++)
{
if(max<arr[x])
max=arr[x];//比较后，将较大的值赋给max变量。
}
return max;
}
public static int getMin(int[] arr)
{
int min = arr[0];//定义一个变量，并将数组中0角标的值赋给这个变量。
for(int x = 1;x<arr.length;x++)
{
if(min>arr[x])
min =arr[x];//比较后，将较小的值赋给min变量。
}
return arr[min];
}
}

复制代码

作者: 麦兜是个猪 时间: 2015-6-5 11:18
本帖最后由麦兜是个猪于 2015-6-5 11:32 编辑

数组中的选择排序和冒泡排序：

选择排序：选择一个位置和其他位置比较，在选择下一个位置和剩下的位置比较，内循环结束一次最值出现在头角标位置上。

我们用下边的一个例子来说明，这是我们要进行选择排序的数组：【49 38 65 97 76 13 27 49】

第一次排序后 13 【38 65 97 76 49 27 49】

第二次排序后 13 27 【65 97 76 49 38 49】

第三次排序后 13 27 38 【97 76 49 65 49】

第四次排序后 13 27 38 49 【49 97 65 76】

第五次排序后 13 27 38 49 49 【97 97 76】

第六次排序后 13 27 38 49 49 76 【76 97】

第七次排序后 13 27 38 49 49 76 76【 97】

这样就比较直观了，很明显是嵌套循环尖朝下的结构，所以我们可以改变内循环的初始化值，让初始化值随着外循环变化。

冒泡排序：数组中相邻的两个元素进行比较，如果符合条件，换位，第一圈比较完后，最值出现在最后一位，第二圈比完后，最值出现在倒数第二位......，循环比较，除了每次比较完的最后一个，因为那一个已经是之前进行比较的一组的最值了，下次不需要在纳入比较的范围之内。

学的时候就在想为什么要叫冒泡排序，原来是因为随着循环的对这些数进行位置置换，最值会慢慢的浮出来，所以才叫冒泡的吧。

下面是冒泡排序和选择排序的代码：

/*
需求：对数组进行选择排序和冒泡排序。上边已经详细的说过这两个排序，所以在代码里就不写思路和步骤了。
*/
class ArraySort
{
public static void main(String[] args)
{
int[] arr = {12,345,21,3,13,34,2,1};
printArray(arr);//偷个懒，遍历数组前边已经写了方法，这里直接用吧,在这打印排序前的数组。
//int[] arr1 = selectSort(arr);//选择排序验证了，没有问题。
int[] arr1 = bubbleSort(arr);
printArray(arr1);
}
//选择排序
public static int[] selectSort(int[] arr){
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
return arr;
}
//冒泡排序
public static int[] bubbleSort(int[] arr){
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)//-x：每次比较完，都会一个确定的值不用再参加下一次比较；-1：是为了防止角标越界。
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
return arr;
}
public static void swap(int[] arr,int x,int y)//这个是位置置换功能。
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
｝

复制代码

数组的查找操作：

折半查找：首先一定要保证要进行查找的数组是有序的，先定义两个变量，一个赋值为0角标，作为最小值，一个赋值为最后一个角标，作为最大值再定义一个变量，存储最小值与最大值的一半，也就是数组的中间位置，然后将已知的值与中间位置元素的值进行比较，如果比中间元素的值大，则将最小值赋值为中间值加1，继续取最小值与最大值的中间值元素与已知元素进行比较，如果比中间元素的值小，则将最大值赋值为中间值减1，继续取最小值与最大值的中间值元素与已知元素进行比较，如果比较到最后最小值已经大于最大值了，说明这个元素在数组中不存在，这时我们返回-1。

代码如下：我把两个方法都写进去，其实都是差不多的。

/*
折半查找
*/
class ArrayBinarySearch
{
public static void main(String[] args)
{
int[] arr = {3,11,23,34,45,56,76,87};//注意，这个数组一定要是有序的。
int num = binarySearch(arr,23);
System.out.println("num="+num);
}
public static int binarySearch(int[] arr,int key)
{
//方法一
/*
int min,max,mid;
max = arr.length-1;
min = 0;
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;
}
return mid;
*/
//方法二
int min,max,mid;
min = 0;
max = arr.length-1;
while(min<=max)
{
mid = (max+min)/2;
if(key>arr[mid])
min = mid+1;
else if(key<arr[mid])
max = mid-1;
else
return mid;
}
return -1;//如果我们要把一个数插入到数组中，把这里改成return min;就可以了。
}
}

复制代码

进制转换：

直接上查表法吧：将所有的元素临时存储起来，建立对应关系，将每次做完&运算的值(&的值根据你要转换的进制而定，&15是转16进制，&7是转8进制，&1是转二进制)作为索引去查表，就可以查到对应的元素，然后再将这个值右移(位数由你要转的进制而定，16进制4位，8进制3位，2进制1位)。下面是代码：

/*
查表法十进制----十六进制
*/
class ToHexDemo
{
public static void main(String[] args)
{
toHexCha(45,15,4);
}
public static void toHexCha(int num,int yushu,int weiyi)
{
char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
//方法一直接查表打印
/*
for(int x=0;x<8;x++)
{
int temp = num & yuShu;
System.out.print(chs[temp]);
num = num>>>weiyi;
}
*/
//方法二 StringBuilder容器
/*StringBuilder sb = new StringBuilder();
for(int x=0;x<8;x++)
{
int temp = num & yushu;
num = num>>>weiyi;
sb.append(chs[temp]);
}
System.out.println(sb.reverse());
*/
//方法三存到数组中
char[] arr = new char[8];
int pos = arr.length-1;//arr.length;
while(num!=0)
{
int temp = num & yushu;
num = num>>>weiyi;
arr[pos--] = chs[temp];//arr[--pos];
}
for(int x=pos+1;x<arr.length;x++)//x=pos;
{
System.out.print(arr[x]);
}
}
}

复制代码

这些是我准备写到技术博客里的笔记，今天才看到这个帖子，不知道活动结束了没，不管怎么样，放在这里，弄不好我的这些笔记能对其他人有点作用，记得不好的地方也请各位大神不要喷。

作者: 我本灬无名 时间: 2015-6-6 22:16
笔记内容：数组笔记来源：刘意java视频第5天
内容:上课的时候，跟着夯哥做的，后面还有学API 的时候，超哥给补充的选择排序。
 找了半天，代码太多了。翻不到。只提交理论知识啦。。
数组：
概述：存储多个，同一种类型的元素的容器。
好处：可以对数组的元素进行编号，从0开始。
数组的定义格式：
元素类型[] 数组名 = new 元素类型[数组长度和个数]
new; 申请内存空间。

怎么获取数组中的元素：
第一个：arr[0];
第二个：arr[1];
第三个：arr[2];

内存的划分：
栈：存的是局部变量。
局部变量;定义在方法中，或者方法的形式参数上的。
特点：当变量使用完毕后（超出了变量的作用域。），直接从内存中释放。

堆：存的是new出来的东西（实体）。
1、每一个实体都有地址值。
2、每一个实体都有默认初始化值。
整数：0
浮点：0.0
字符：'\u0000'
布尔：false
3、在不确定的时间被垃圾回收器（ GC）回收掉。
方法区：里面存储的：方法，String常量池，静态区。byte常量池。
本地方法区：和系统相关的内容。
寄存器：有CPU来分配资源的。
定义数组的四种方式：此处以Int类型举例
A： int[] arr = new int[5];//定义一个int类型的数组 arr
B: int arr[] = new int[5];//定义一个int类型的 arr数组
c: int[] arr = new int[]{1,2,3,4};
D: int[] arr = {1,2,3,4,5};
推荐 A D

数组的常见操作：
1、数组的遍历：
数组名怎么求：数组名.length
长度：从1-数组名 .length
索引： length-1
 for (x =0 ;x <arr.length;x++)
 {
System.out.println(arr[x]);
 }
2、数组的求最大值：
数组的求最大值：
1、定义一个变量max记录最大值。
2、遍历数组，拿到每一个元素，然后依次来跟最大值比较。
如果遍历到的元素，比最大值大，把该元素的值赋值给max。
3、将最大值返回。
int[] arr = {1,2,3,4,5};
int max = arr[0]; //我们假设数组中的第一个元素是最大值。
for(int x=0;x<arr.length;x++)
{
//arr[x]就是数组中的元素
if(arr[x]>max) //判断当前遍历到的元素是否比max大，
 //如果比最大值还大，就将该值赋值给max
{
max = arr[x];
}
}
System.out.println(max); //输出最大值。
3、数组的基本查找功能：
1、定义一个变量记录要查找的值。key
2、遍历数组，拿到每一个元素，然后依次来跟key来比
如果相等，即返回该元素的索引（下标）
如果不相等，返回 -1
数组常见错误：

/*
数组操作的常见问题：
A:数组越界异常。访问了不存在的索引。
ArrayIndexOutOfBoundsException
B:空指针异常。一个实例(对象)已经不存在
NullPointerException
*/
class ArrayDemo3
{
public static void main(String[] args)
{
//定义数组
int[] arr = {1,2,3,4,5};
//使用元素
System.out.println(arr[3]);
//System.out.println(arr[5]);
//错误的
//int x = null;
arr = null;
System.out.println(arr[2]);
}
}

复制代码

二维数组：
概述;就是每个元素都是一维数组。
A：int[][] arr = newunt[n][m];
n:可以看做是行，代表arr这个二维数组有多少元素。
m:可以看做是列。代表每一个一维数组中有多少个元素。
B:int [][]arr = new int[n][];
n:可以看作是行。代表arr这个二维数组中有多少个一维数组。
第二个括号的意思是，每一个一维数组的长度不固定。
C:int[][]arr = {{1,2,3}{1,2}{7,54}};

二维数组的遍历：
二位数组的长度：
arr.length
每一个以为数组的长度：
arr[x].length
二维数组的元素。
arr[x][y]
应用：
计算上场的年销售额

作者: dcw2015 时间: 2015-6-7 16:16
笔记内容：数组
笔记来源：毕向东Java基础视频第4天正文：
数组：
用来存储同一数据类型元素的容器。（数据类型可以是基本的 int、long、float、double、String娄型也可以是娄类型噢。娄类型存储的是对象的哈希修值）
下面我就用一个随机点名器来给大家演示下数组的运用吧，这个是昨天老师布置的作业，写的不好的、需要改进的还请各位大神指出来啊
/**
需求：
制作一个随机点名器，程序运行一次后，输入１继续随机点名，输入０跳出程序

思路：
Ａ：定义一个String娄数组，用于存储名单
Ｂ：用Math.random()方法随机一个数，用这个数来指向对应名单的角标
Ｃ：运行完一次后输入１则继续随机点名，输入０结束程序

*/
import java.util.Scanner;

class RandomDemo{
public static void main (String[]args){

//这里定义了一个字符串数组，用来存储全班同学的名字
String[] name={"郭海飞","刘和平","覃奕丹","冯利","杨长树","姚聚龙","李映伟",
"陈炎荣","王勇","封海","郑镇发","吴荣基","李林","朱亚林",
"易子豪","阮汉斌","石刚","杨浪","林宏","邓华东","刘晨","张鹏",
"张杨"," 杨明","欧阳帆","谢海尧","吴超超","张贻建","张晓宇","黄峰",
"田植成","赖坚","郑嘉鑫","徐剑","郭坤鹏","邓少武","周木涨",
"张龙盛","黄新荣","李琦","刘佳栋","金刁","张业涛","杨杰","李晓岑",
"张建红","吴昊","彭敦","潘秋颖","胡淼","杨佳辉","李俊豫","林山淼",
"李聪","唐骏方","刘裕楷","邝泽雨","田朝明","蓝天宏","黄洋","谭彭武",
"李群杰","张勇","黄春","黄麒","皮德龙","李游","施斌","张臣","唐志文",
"郑伟宁","吴忠园","魏锦誉","陈锋华", "李铁"};

System.out.println("咱班一共有"+name.length+"人，下面开始点名");

//因为后面需要键盘录入要用到Scanner这个娄，所在这里创建了一个Scanner对象

Scanner sc = new Scanner(System.in);

/**用于接受随机数，并将其当作角标指入对应角标元素*/
int index;

/**用于接收用户输入的数字，判定程序是否继续*/
int num;
do{
do{
/**这里调用了Math里的random()方法，random()方法是随即返回一个大于0但无限小于1的double类型的小数，这里将random()方法返回的值*100并加上0.1是取小数点后三位有效数字*/
index = (int)(Math.random()*100+0.1);
}
/**判断随机数是否超出数组长度，超出则重新随机一个数*/
while (index>=75);
/**把随机生成的数字当成索引，并输出索引对应的学生名字*/
System.out.println(name[index]);

System.out.println("是否继续点名？(1继续，0退出)");
/**接受键盘录入的数字并赋值给num*/
num=sc.nextInt();
/**判断键盘录入的数字是不是1和0以外的数字*/
while(num!=1 && num!=0 ){

System.out.println("请不要输入1和0以后的数字，请重新输入");
/**如果键盘录入的是1和0以外的数字，则重新录入并再次赋值给num*/
num=sc.nextInt();
}
/**判断输入数字是否为0，为0是退出，否则继续*/
}while (num!=0);
System.out.println("点名结束");
}
}

作者: dcw2015 时间: 2015-6-7 16:19
:dizzy:忘记给同学名字打马赛克了。。。还有代码回贴要怎么弄出表格来啊。求告知

作者: 夕阳醉 时间: 2015-6-9 00:06
本帖最后由夕阳醉于 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);
}
}

复制代码

作者: 张沐风 时间: 2015-6-9 00:14
笔记内容：数组
笔记来源：毕向东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 时间: 2015-6-11 00:37
本帖最后由 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 时间: 2015-6-17 17:00
回帖格式：
 笔记内容：数组
 笔记来源：毕向东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 时间: 2015-6-17 17:57
笔记内容：数组
      笔记来源：毕向东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 时间: 2015-6-20 23:31
笔记内容：数组
笔记来源：毕向东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 时间: 2015-6-20 23:40
本帖最后由 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 时间: 2015-6-21 20:47
本帖最后由 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}

无标题.png (73.46 KB, 下载次数: 2)

无标题1.png (76.67 KB, 下载次数: 4)

作者: IT黑马 时间: 2015-6-21 22:36
我想说，我是来学习笔记的

作者: j420984 时间: 2015-6-22 09:52
笔记内容：常用数组操作
 笔记来源：毕向东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 时间: 2015-6-26 22:01
笔记内容：数组
笔记来源：毕向东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 时间: 2015-7-9 23:07
笔记内容：数组笔记来源：刘意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-11 21:25
本帖最后由黑马和大灰狼于 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] + "]" );
}
}
}

复制代码

作者: 我是新生 时间: 2015-7-11 21:27

我没有专门做数组的笔记,不过我们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:03
本帖最后由冷风然于 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();
 }
 }
 }

辛东泽作业.png (71.6 KB, 下载次数: 4)

不太会用画图会的...

作者: joe520kay 时间: 2015-7-22 14:18
本帖最后由 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;
}
}

复制代码

作者: 白羽蘇芳 时间: 2015-7-25 21:05
笔记内容：数组
笔记来源：黑马程序员_毕向东最新经典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;
}
}

复制代码

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

作者: 白羽蘇芳 时间: 2015-7-25 21:08
例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反转过来打印结果
}
}

复制代码

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

作者: 白羽蘇芳 时间: 2015-7-25 21:09
例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。

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

作者: 唐磊 时间: 2015-7-28 00:02
笔记内容：数组
笔记来源：刘意老实Java基础视频第4天
正文格式：
数组格式
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];通过new关键字创建了一个长度为5，元素类型是int的数组实体,并把这个数组实体赋值给引用类型变量 arr, 所以arr的类型是int[] (int类型数组)
会打印数组的内存地址（暂且这样记忆，之后会详细讲解），可以通过索引获取指定位置的元素

int [] arr = new int[5];

数据类型：
　基本类型；４类８种。
引用类型；类，借口，数组。

左边；
int；表示数据类型。
[]；表示这是一个数组
arr；数组的名字。

右边；
new;
int;表示数据类型。
[]；表示一个数组
5；数组的长度

其他三种数组格式 A int[] arr =new int[2];//念法:int类型的数组arr
 B int arr[] = new int[2];//念法:int 类型的arr数组,不推荐这么写,他和第一种格式其实一样的
 C int[] arr = new int[]{1,2,3,7};//大括号内可以没有任何东西
 D int[] arr = {3,4,65,4};//大括号内可以没有任何东西

 System.out.println(arr2) 是打印 arr2的十六进制字符
System.out.println(arr[2]) 是打印堆中角标为3的元素

class Demo
{
public static void main(String[] args)
{
double[] arr1 = new double[2];
int[] arr2 = new int[2]; //arr1 arr2 arr3就相当于变量x y z
char[] arr3 = new char[3]; //
boolean[] arr4 = new boolean[3];
System.out.println(arr2);
}

}*/

/*
需求：我要获取一个数据肿么办？
通过索引（类似于字典的索引）。格式：数组名【索引】
arr[0] arr[1]

Java内存图：
A:栈存储局部变量使用。局部变量：定义在方法中或者方法声明上的形式参数都叫做局部变量
使用完毕，立马消失。

B:堆所有new出来的都在堆里面。
a:每一个实体都有地址值 本身是十进制，显示的是十六进制
b:每一个实体内的内容都有默认值
整数：0
浮点数：0.0
字符：'\u0000'
布尔：false
c:实体不再被使用的时候，在垃圾回收器空闲的时候被回收。

C:方法区
D:本地方法区
E:寄存器

需求：我要给第三个元素赋值为10，肿么办？
arr[2]=10; 我说过了 arr[] 就相当于一个变量，[]里面装的是角标

****知识点：数组操作的常见问题

A 数组越界 访问了不存在的索引,如下
ArrayIndexOutOfBoundsException

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,2};

System.out.println(arr[3]);
System.out.println(arr[5]);//没有角标6的元素
}

}
B 空指针异常。一个实例对象都已经不存在了，你还要访问
NullPointerException

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,2};

arr=null; //重新给arr赋值，以前是堆的地址值赋值给arr,
现在是null赋值给arr,arr就不会通过地址值指向堆

System.out.println(arr[3]); //arr 已经是个空的了
}

}
/*
知识点；多个数组指向同一个实例

class Demo
{
public static void main(String[] args)
{
int[] arr=new int[3];
arr[0]=1;
arr[1]=3;
arr[2]=5;

int[] arr2=arr; //再定义一个数组，把数组arr的值（地址值）付给了arr2
arr2[1]=10;

System.out.println(arr[1]);//10

System.out.println(arr2[2]);//5
}

}
*/
/*
知识点；遍历 获取数组中的所有元素

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};

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]);
}

}
//通过循环改进，把所有数组中元素罗列出来

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};

for (int x=0;x<5;x++) //x定义的是脚标 0 1 2 3 4
{
System.out.println(arr[x]);
}
}

}
//如果数据太多，就没办法了遍历么？？
//假如有人能够提供我们数组的长度，就可以做了(x<?)
// java 提供了一个属性 length
格式；数组名.length
class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};

for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
System.out.println(arr[x]);
}
}

}

需求；数组遍历 用方法
思路
返回值类型；void
参数列表；int[]arr

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};
int[] arr2={34,415,515,321,54,52,37,73,42};
printArray(arr); //执行一遍函数

printArray(arr2); // 再执行一遍函数
}
public static void printArray(int[] arr) // 传送数组 arr无所谓他和上面的arr1 arr2没有联系其实传送的是空，直接就打印出来了 {
for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
System.out.println(arr[x]);
}
}
}

*/
/*
需求，求数组中的最大值
思路
1.需要进行比较，并且定义变量记住每次比较后较大的值
2.对数组中的元素遍历取出，和变量记住的元素进行比较
 如果遍历的元素大于变量中记录的元素，就用变量记住较大的值。
3.遍历结果，该变量记住的就是最大值。

定义一个功能实现

明确1 结果。
是数组中的元素，int
明确2 未知内容
数组

class Demo
{
public static void main(String[] args)
{

int[] arr={34,415,515,321,54,52,37,73,42};

int max = getMax(arr); //先定义，在打印输出，这都错！！MD！！///?????????

System.out.println(max);

}
//方法1 定义元素
public static int getMax(int[] arr)
{ // 传送数组 arr无所谓他和上面的arr1 arr2没有联系 {
int max=arr[5]; //定义 int max=0 就是让每次循环中元素跟0对比，
//假如元素中都是负数，那没就会输出最大值是0
//所以定义max 可以随意定义一个 数组中的任何一个元素

//初始化数组中的 元素可以，那么初始化元素中的角标可不可以呢？怎么可以做到呢
// 可以，因为元素跟角标有着对应关系

for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
if (arr[x]>max)
{
max=arr[x]; //每遍历一次数组中的元素都要循环做一次比较
}
}

return max; //错误忘了加分号
}

// 方法2（定义角标）运行方法2的时候需要把int max = getMax(arr);改成int max = getMax2(arr);

public static int getMax2(int[] arr)
{
int maxIndex=0; //初始化定义一个角标也可以，因为角标对应着元素

for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
if (arr[x]>arr[maxIndex]) //元素跟角标对应的元素作对比
{
maxIndex=x; //
}
}

return arr[maxIndex]; //错误忘了加分号
}
}*/

作者: wode1311 时间: 2015-7-31 22:34
本帖最后由 wode1311 于 2015-7-31 22:44 编辑

笔记内容：数组的基础知识和应用
笔记来源：毕向东Java基础视频第5天
正文：
1、基础概念： [url=]

数组是存储多个同一类型数据元素的容器，数组中的元素会被自动从0开始编号，方便我们获取。

分类：

一维数组（4种定义格式）：

int[] arr =new int[2];

int arr[] = new int[2];

int[] arr = new int[]{1,2,3,7}; //大括号内可以没有任何东西

int[] arr = {3,4,65,4}; //大括号内可以没有任何东西
二维数组（三种定义格式）：

第一种定义通过定义长度的方式定义了二维数组的长度，并且定义了一维数组的长度 int[][] arr = new int[6][3]

第二种定义通过长度仅定义了二维数组的长度，没有初始化一维数组int[] [] arr= new int[2][]

第三种定义通过直接给出元素定义了二维数组的长度和每一个一维数组的长度 int[][] arr = {{2,23},{33}}

2、数组操作：

1、数组遍历：

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

System.out.print(arr+"\t");

}

2、获取数组最值
 public int getMax(int[] arr){
 int temp=arr[0];
 for(int i=1;i<arr.length;i++){
 if(arr>temp){
 temp=arr;

 }
 }
 return temp;
 }

3、数组查找：给定一个值，查找该值在数组中对应的索引

public static int indexFirst(int[] arr, int num) {
 for (int i = 0; i < arr.length; i++) {
 if (arr == num) {
 return i;
 }
 }
 return -1;
 }

3、数组应用：

[/url] 1 、利用数组自定义一个可变长度的容器，可存储不同的数据。

import java.util.Scanner;
class Container {
Object[] src;// 存放数据的数组
/** 通过add方法将val添加到容器内 */
public void add(Object val) {
if (src != null) {
Object[] arr1 = new Object[src.length + 1];
for (int i = 0; i < src.length; i++) {
arr1[i] = src[i];
}
arr1[src.length] = val;
src = new Object[arr1.length];
for (int i = 0; i < src.length; i++) {
src[i] = arr1[i];
}
} else {
src = new Object[1];
src[0] = val;
}
}
/** 通过给get方法传递一个索引，可以获取到该索引位置对应的值 */
public Object get(int index) {
return src[index];
}
/** 通过lenth()可以获取该容器中存储了多少个数据 */
public int length() {
return src.length;
}
}
class Contain {
public static void main(String[] args) {
Container c = new Container();
int tip;
Object o;
while (true) {
System.out.println("请输入一个数据(1整型2浮点型3布尔型4字符串0停止)：");
Scanner sc = new Scanner(System.in);
tip = sc.nextInt();
if (tip == 0) {
break;
} else {
o = setContent(tip);
c.add(o);
}
}
for (int i = 0; i < c.length(); i++) {
System.out.println("第" + i + "个数据是:" + c.get(i));
}
System.out.println("共有" + c.length() + "个数据");
}
public static Object setContent(int tip) {
Scanner sc = new Scanner(System.in);
int i;
double d;
boolean b;
String s;
Object o = null;
while (true) {
if (tip == 1) {
i = sc.nextInt();
o = i;
break;
} else if (tip == 2) {
d = sc.nextDouble();
o = d;
break;
} else if (tip == 3) {
b = sc.nextBoolean();
o = b;
break;
} else if (tip == 4) {
s = sc.next().toString();
o = s;
break;
} else {
System.out.println("输入非法数据，请重新输入...");
break;
}
}
return o;
}
}

复制代码

2、数组拷贝，获取数据在数组中的位置，以及从某个位置开始获取某个元素的相对位置

public static void main(String[] args)
{
int[] a=new int[]{1,2,3,4,5,8,5};
int[] b=new int[a.length];
ArrayCopy(a,b);
char[] c=new char[]{'a','b','c','d','e'};
char d='d';
int location=indexOf(c,d);
System.out.println(d+"在字符数组中的位置是第"+(location+1)+"个元素");
char[] arr=new char[]{'1','2','3','4','6','9'};
int position=indexOf(arr,2,'4');
System.out.println("从第二个位置开始,4所在的位置是第"+position+"个元素");
}
//数组拷贝
public static void ArrayCopy(int[] a,int[] b){
for(int i=0;i<a.length;i++){
b[i]=a[i];
}
}
//获取元素位置
public static int indexOf(char[] chs, char ch){
for(int i=0;i<chs.length;i++){
if(chs[i]==ch){
return i;
}
}
return -1;
}
//获取元素的相对位置
public static int indexOf(char[] chs,int startIndex,char ch){
int count=1;
for(int i=startIndex-1;i<chs.length;i++){
if(chs[i]==ch){
return count;
}
count++;
}
return -1;
}

复制代码

3 、房间案例（二维数组）：一栋楼有7层，每层有10个房间，那么就把大楼看成一个二维数组，里面的每层是一维数组。

class RoomDemo
{
public static void main(String[] args)
{
int[][] room = new int[7][10];
for(int i=0; i<room.length; i++)
{
int[] floor = room[i];
for(int j=0; j<floor.length; j++)
{
System.out.println("正在第"+(i+1)+"层中的第"+(j+1)+"个房间");
}
}
}
}

复制代码

作者: jipinxianren 时间: 2015-9-22 21:44
一、数组【掌握】
1、数组：存储同一种数据类型的多个元素的容器。

2、特点：每一个元素都有一个编号，从0开始，最大编号是数组长度 - 1。
这个编号的专业叫法：索引。

3、格式：
(1)动态初始化
只指定长度，由系统给出初始化值
A:int[] arr = new int[3];
//B:int arr[] = new int[3];

(2)静态初始化
给出初始化值，由系统计算长度
A:int[] arr = {1,2,3};
//B:int[] arr = new int[]{1,2,3};

两种初始化都推荐A方案

4、Java内存图：
A:栈存储局部变量; 方法在栈里面调用(压栈)
局部变量:定义在方法声明上和方法中的变量
方法调用完毕会弹栈，方法内部的局部变量也随之消失。

B:堆所有new出来的都在堆内存里面。
a:每一个对象都有地址值
b:堆内存里面每一个基本数据类型的变量都有默认值
整数：0 byte, short, int
浮点数：0.0 float, double
字符：'\u0000' char
布尔：false boolean

C:方法区（面向对象部分讲解）
D:本地方法区（和系统相关）
E:寄存器（CPU使用）

5、数组内存图
A:一个数组
B:二个数组
C:三个数组(两个栈里面的局部变量指向同一个堆内存)

6、常见操作：【重点掌握】
A:遍历
方式1：
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}

方式2：
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
} else {
System.out.println(arr[x]+", ");
}
}
}

B:最值
最大值：
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}

C:反转
方式1：
public static void reverseArray(int[] arr) {
for(int i=0; i<arr.length/2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}

方式2：
public static void reverseArray(int[] arr) {
for(int start=0,end=arr.length-1; start<=end; start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}

D:查表
public static String getString(String[] strArray, int index) {
return strArray[index];
}

E:基本查找
public static int getIndex(int[] arr,int value) {
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
return x;
}
}
return -1;
}

7、二维数组【理解】
格式：
A:int[][] arr = new int[3][2]; //有三个一位数组，每个一维数组里面有2个int元素。
B:int[][] arr = new int[3][];
C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

遍历：
public static void print(int[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}

求和：
public static int getSum(int[][] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
sum += arr[i][j]
}
}
return sum;
}

二、参数传递【掌握】
public static void main(String[] args) {
int a = 10;
int b = 20;
change(a, b);
System.out.println("a=" + a + ", b=" + b); //a=10, b=20

int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //arr[1] = 4;
}

public static void change(int a, int b) {
a = b;
b = a + b;
}

public static void change(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(arr[x]%2 == 0) {
arr[x] *= 2;
}
}
}

结论：
基本数据类型的值传递,不改变原值,因为方法在栈里面调用，调用完毕后方法会弹栈,局部变量也随之消失;
引用数据类型的值传递,改变原值,因为即使方法弹栈,但是堆内存数组对象还在,可以通过地址继续访问

简单记：
A: 基本数据类型作为方法参数传递时，形参的改变不影响实参;
B：引用数据类型(数组，类，接口)作为参数传递时，形参的改变影响实参。

面试题：Java中到底是传值还是传址
A：既是传值,也是传地址,基本数据类型传递的值,引用数据类型传递的地址
B：java中只有传值,因为地址值也是值【出去面试都说这种,支持者是高司令(java之父)】

作者: 大宝剑 时间: 2015-9-22 23:55
~~~~~~~~~~~~~~

作者: heimatai6 时间: 2015-9-23 18:51
、、、、、、、、、、、、、、

作者: 枫烬 时间: 2015-11-6 00:49
本帖最后由枫烬于 2015-11-6 00:56 编辑

笔记内容：数组
笔记来源：冯佳Java基础视频第6天
正文：

概述

数组是存储同一种数据类型多个元素的集合/容器，可以存储基本数据类型或是引用数据类型。
数据类型[] 数组名 = new 数据类型[数组长度];

[]的个数代表数组的维度

特点：
- 数组的每个元素都有编号（index，索引，角标），从0开始，最大编号为arr.length-1
- 在堆内存里面是一块连续的内存空间
初始化：不允许动静结合
- 动态初始化，指定长度，系统给出初始化值
- 静态初始化，指定初始化值，系统来决定长度

默认初始化值：

整数类型	byte,short,int,long	0
浮点类型	float，double	0.0
布尔类型	boolean	false
字符类型	char	'\u0000'
引用数据类型		null

‘\u0000’:每个0都是代表16进制的0

Sys.out.print(arr); ==>[I@da6

内存

内存区块：

栈	存储局部变量	先进后出
堆	存储new出来的数组或对象
方法区	存储代码
本地方法区	和系统有关
寄存器	cpu用

局部变量：定义在方法声明和方法体里的变量

类文件运行加载后，主方法main以栈针的形式压栈到栈底，定义数组，在堆创建数组的连续空间

异常
- ArrayIndexOutOfBoundsException 数组索引越界异常
- NullPointerException空指针异常

操作

遍历

//遍历数组
public static void testArray01(int[] arr){
for (int i = 0;i < arr.length ;i++ ) {
System.out.print(arr[i]+"\t");
}
System.out.println();
}

复制代码

最大值
1. //获取数组最大值
2. public static void getArrayMax(int[] arr){
3. int max = arr[0];
4. for (int i = 1;i<arr.length ;i++) {
5. if (max < arr[i]) {
6. max = arr[i];
7. }
8. }
9. System.out.println("最大值为："+max+"。");
11. }
复制代码
最小值
1. //获取最小值
2. public static int getArrayMin(int[] arr) {
3. int min = arr[0];
4. for (int i = 1;i <arr.length ;i++ ) {
5. if (min > arr[i]) {
6. min = arr[i];
7. }
8. }
9. return min;
10. }
复制代码
反转
1. //反转
2. public static void reverseArray(int[] arr) {
3. for (int i = 0;i < arr.length/2 ;i++ ) {
4. int temp = arr[i];
5. arr[i] = arr[arr.length-i-1];
6. arr[arr.length-i-1] = temp;
7. }
8. }
复制代码
排序
由值返回角标
1. //由值返回角标
2. public static int getIndex(int[] arr,int value) {
3. for (int i = 0;i < arr.length ;i++) {
4. if (arr[i] == value) {
5. return i;
6. }
7. }
8. return -1;
9. }
10. }
复制代码
由角标返回值
1. //星期
2. public static void getWeek(int week){
3. char[] weekDay = {'一','二','三','四','五','六','日'};
4. System.out.println("这是星期"+weekDay[week-1]+"。");
6. }
复制代码

二维数组

数据类型[ ][ ] 数组名称 = new 数据类型[ a ][ b];

==》a个一维数组，每个一维数组中有b个元素

Int[]x,y[]; x是一维数组，y是二维数组；

默认初始化值是null

参数传递问题：

基本类型数据的值传递，不改变原值，因为调用后会弹栈，局部变量消失。调用时，用的只是将变量的值赋给局部变量。

引用数据类型的值传递，改变原值，因为即使方法弹栈，但堆内存数组对象还在，可通过地址访问

java传值/传址？

只有传值，因为地址值也是值

形参的改变会影响实参吗？

基本数据类型，形参的改变不影响实参

引用数据类型，形参的改变影响实参

作者: 枫烬 时间: 2015-11-6 00:52
我用的onenote做的笔记，复制过来之后格式就难看了==！！！

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2