觉得对你有用就给个鼓励吧~~
数组概念和遍历：

1. * 数组概念:同一种类型数据的集合,其实,数组就是一个容器.
   
2. * 好处:可以自动给数组的元素从0开始编号,方便操作这些元素.
   
3. * 格式1:元素类型[] 素组名 = new 元素类型[元素个数或数组长度]
   
4. *                 int [] arr = new int[5];
   
5. * 格式2:元素类型[] 数组名 = new 元素类型[]{元素1,元素2,元素3,....元素n};
   
6. *                 int[] arr = new int[]{3,5,7,9,0};
   
7. *   或者int[] arr = {1,2,3,4,5,6}
   
8. * 内存划分:1.寄存器 2.本地方法区 3.方法区
   
9. * 4.栈内存 用于存储局部变量,当变量所属的作用域一旦结束,所占空间会自动释放.
   
10. * 5.堆内存 数组和对象,通过new建立的实例都存放在堆内存中.
    
11. * */
    
12. public class ArrayDemo {
    
13. 
    
14.         public static void main(String[] args) {
    
15.                 int[] arrays = {23,34,15,64,678,342,533,234,2,9,-999};
    
16.                 printArrays(arrays);
    
17.                 xuanZe(arrays);
    
18.                 xuanZeJiaoBiao(arrays);
    
19.                 bubble(arrays);
    
20.                 Arrays.sort(arrays);
    
21.                 printArrays(arrays);
    
22.                 arrayDemo(arrays);
    
23.                 getMax(arrays);
    
24.         }
    
25.         public static void arrayDemo(int[] arr){
    
26.                 //int[] arr = new int[]{1,2,3,4,5};
    
27.         //        System.out.println(arr);//[I@170a6001
    
28.                 //[I 表示int类型的数组,@后面是该素组的初始地址哈希值
    
29.                 for (int i = 0; i < arr.length; i++) {
    
30.                         System.out.println(arr[i]);
    
31.                 }
    
32.         }
    
33.         public static void getMax(int[] arrays){
    
34.                 int max = 0;
    
35.                 for (int i = 0; i < arrays.length; i++) {
    
36.                         max = arrays[i] > max ? arrays[i]:max;
    
37.                 }
    
38.                 System.out.println(max);
    
39.         }
    
40.         //排序问题:
    
41.         //选择排序:用第一个元素依次和后面的元素做比较,确定第一位最小,然后拿第二个和后面的依次比较
    
42.         //采用选择排序--基本方法
    
43.         public static void xuanZe(int[] arr){
    
44.                 for (int x = 0; x < arr.length-1; x++) {        
    
45.                         for (int y = x+1;y < arr.length; y++) {
    
46.                                 if(arr[x]>arr[y]){
    
47.                                         int temp = arr[x];
    
48.                                         arr[x] = arr[y];
    
49.                                         arr[y] = temp;                                
    
50.                                 }
    
51.                         }
    
52.                 }        
    
53.         }
    
54.         //遍历方法
    
55.         public static void printArrays(int[] array){
    
56.                 System.out.print("[");
    
57.                 for (int i = 0; i < array.length; i++) {
    
58.                         if( i < array.length-1){
    
59.                         System.out.print(array[i]+",");
    
60.                         } else {
    
61.                                 System.out.println(array[i]+"]");
    
62.                         }
    
63.                 }
    
64.         }
    
65.         //选择排序之角标记录法
    
66.         public static void xuanZeJiaoBiao(int[] arrays){
    
67.                 for (int i = 0; i < arrays.length-1; i++) {
    
68.                         int index = i;
    
69.                         int min = arrays[i];
    
70.                         for(int j = i+1 ; j<arrays.length;j++){
    
71.                                 if(arrays[j]<min){
    
72.                                         min = arrays[j];//获取到本循环数组最小值min
    
73.                                         index = j;//本循环结束后获取到整个数组最小值的索引j
    
74.                                 }
    
75.                                 if(i != index){
    
76.                                         replace(arrays,i,index);
    
77.                                 }               
    
78.                         }
    
79.                 }
    
80.         }
    
81.         //替换arrays[i]
    
82.         public static void replace(int[] arrays,int i,int index){
    
83.                 int temp = arrays[i];
    
84.                 arrays[i] = arrays[index];
    
85.                 arrays[index] = temp;
    
86.         }
    
87.         //冒泡排序:第一轮:从第一个元素到倒数第二个元素依次向右比较,把最大数挪到最右边.
    
88.         //       第二轮:从第二个元素到倒数第三个元素依次向右比较,把第二大数挪到倒数第二.
    
89.         public static void bubble(int[] arr){
    
90.                 for (int j = 0; j < arr.length-1; j++) {
    
91.                         for (int i = 0; i < arr.length-j-1; i++) {
    
92.                                 if(arr[i]>arr[i+1]){
    
93.                                         int temp = arr[i];
    
94.                                         arr[i] = arr[i+1];
    
95.                                         arr[i+1] = temp;
    
96.                                 }
    
97.                         }
    
98.                 }
    
99.         }
    
100. }

复制代码

输出结果：

程序运行的结果为：

[23,34,15,64,678,342,533,234,2,9,-999]
[-999,2,9,15,23,34,64,234,342,533,678]
-999
2
9
15
23
34
64
234
342
533
678
678

觉得对你有用就给个鼓励吧~~

谢谢分享

谢谢分享~

66666666666666666666

学霸你好，学霸再见

今天刚刚学习了数组，看到楼组的总结又稍稍复习了一遍，下边的排序问题可能明天老师要讲，提前预习一下哈。谢谢了

最好不要用拼音，会养成不好的习惯

隔壁马良 发表于 2015-11-21 00:22
最好不要用拼音，会养成不好的习惯

O(∩_∩)O谢谢!

复写了{:2_36:}