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

本帖最后由温暖的小白于 2015-5-12 22:45 编辑

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

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

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

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

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

anywayDo · anywayDo

笔记内容：数组
笔记来源：毕向东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 · c523106

本帖最后由 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);
}
}

复制代码

只想好好的 · 只想好好的

笔记内容：数组及数组内存的划分
笔记来源：毕向东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 · anywayDo

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

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

李工 · 李工

本帖最后由李工于 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 · V_nan

本帖最后由 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 · V_nan

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

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

猿-动力 · 猿-动力

记内容：数组（静态初始化-常见问题）
      笔记来源：毕向东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 · zww594509950

笔记内容：数组的几个重要练习
笔记来源：毕向东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 · urankwong

本帖最后由 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 · V_nan

版主，补完自己总结的了，求打赏

温暖的小白 · 791008594

本帖最后由 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

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

汤姆大叔 · 汤姆大叔

笔记内容：数组
      笔记来源：毕向东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;
}
}

复制代码

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

汤姆大叔 · 汤姆大叔

八：查表法二进制终结版本：

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

复制代码

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

我本灬无名 · 我本灬无名

笔记内容：数组笔记来源：刘意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 · dcw2015

笔记内容：数组
笔记来源：毕向东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("点名结束");
}
}

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

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

50 个回复

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

浏览过的版块

黑马土豪金

优秀版主勋章

优秀作者

黑马骑士勋章