java数组

简介:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/*
知识点:数组
*/
class ArrayDemo
{
 
     public static void main(String[] args)
     {
         /*
         //数组大小
         int size = 3;
         
         //定义数组
         double[] myList = new double[size];
 
         //初始化数组
         myList[0] = 1.2;
         myList[1] = 3.0;
         myList[2] = 9.23;
 
         //计算所有元素的和
         double total = 0;
         for (int i=0; i<size; i++)
         {
             total += myList[i];
             System.out.println(myList[i]);    
         }
         System.out.println("和 = " + total);
         */
 
         //数组的静态初始化(不用指定数组大小,有系统指定数组大小)
         /*
         String[] name = new String[]{"tantianran", "laowang"};
         int[] age = new int[]{25, 30};
         for (int i=0; i<name.length; i++)
         {
             System.out.println("name:"+name[i]+"age:"+age[i]);
         }
         */
         
         /*
         //数组的动态初始化(由人为设置元素个数)
         int[] nums = new int[3];
         for (int i=0; i<nums.length; i++)
         {
             System.out.println(nums[i]);
         }
         */
         
         /*
         //数组的基本操作
         int[] numsl = new int[]{12,3,5,7,9};
         System.out.println("数组长度=" + numsl.length);
         System.out.println("数组的第1个元素="+numsl[0]);
         System.out.println("数组的第2个元素="+numsl[1]);
         //修改索引为1的元素
         numsl[1] = 200;
         System.out.println("数组的第2个元素(修改后)="+numsl[1]);
 
         //遍历数组元素
         System.out.println("----------遍历数组元素-----------");
         for (int i=0; i<numsl.length; i++)
         {
             System.out.println(numsl[i]);
         }
         */
         
         /*
         //获取数组中最大的元素
         int[] data_array = new int[]{4,7,20,9,4,2};
         int max_num = ArrayDemo.getMax(data_array);
         System.out.println("最大值是=" + max_num);
 
         //按格式打印数组元素
         String[] arr = {"A", "B", "C", "D", "E"};
         ArrayDemo.printArray(arr);
         */
 
         /*
         //逆序排序数组中的元素
         String[] acc = new String[]{"A","B","C"};
         ArrayDemo.printArray(acc);
         String[] new_acc = ArrayDemo.reverse(acc);
         ArrayDemo.printArray(new_acc);
         */
 
         //元素出现索引(线性搜索)
         int [] arr = { 10 , 20 , 30 , 10 , 50 ,- 30 , 10 };
     }
     
     static  int  getIndex()
     {
             
     }
     
     //定义一个获取元素最大值的方法
     static  int  getMax( int [] array)
     {
         int  max = array[ 0 ];
         for  ( int  i= 0 ; i<array.length; i++)
         {
             if  (array[i] > max)
             {
                 max = array[i];
             }
         }
         return  max;
     }
 
     static  void  printArray(String[] arr)
     {
         String ret =  "[" ;
         for  ( int  i= 0 ; i<arr.length; i++)
         {
             ret = ret + arr[i];
             if  (i != arr.length - 1 )
             {
                 ret = ret +  ", " ;
             }
         }
         ret = ret +  "]" ;
         System.out.println(ret);
     }
 
     static  String[] reverse(String[] oldArr)
     {
         //创建一个新的数组,存储逆序后的元素
         String[] new_arr =  new  String[oldArr.length];
         for  ( int  i=oldArr.length- 1 ; i>= 0 ; i--)
         {
             new_arr[oldArr.length- 1 -i] = oldArr[i];    
         }
         return  new_arr;
     }
}



本文转自 TtrToby 51CTO博客,原文链接:http://blog.51cto.com/freshair/2055216

相关文章
|
3月前
|
存储 缓存 算法
Java 数组
【10月更文挑战第19天】Java 数组是一种非常实用的数据结构,它为我们提供了一种简单而有效的方式来存储和管理数据。通过合理地使用数组,我们能够提高程序的运行效率和代码的可读性。更加深入地了解和掌握 Java 数组的特性和应用,为我们的编程之旅增添更多的精彩。
42 4
|
3月前
|
存储 缓存 算法
提高 Java 数组性能的方法
【10月更文挑战第19天】深入探讨了提高 Java 数组性能的多种方法。通过合理运用这些策略,我们可以在处理数组时获得更好的性能表现,提升程序的运行效率。
50 2
|
3月前
|
存储 Java
Java“(array) <X> Not Initialized” (数组未初始化)错误解决
在Java中,遇到“(array) &lt;X&gt; Not Initialized”(数组未初始化)错误时,表示数组变量已被声明但尚未初始化。解决方法是在使用数组之前,通过指定数组的大小和类型来初始化数组,例如:`int[] arr = new int[5];` 或 `String[] strArr = new String[10];`。
110 2
|
3月前
|
存储 Java
什么是带有示例的 Java 中的交错数组?
什么是带有示例的 Java 中的交错数组?
62 9
|
3月前
|
Java
Java数组动态扩容和动态缩减
Java数组动态扩容和动态缩减
31 3
|
3月前
|
存储 算法 Java
Java一分钟之-数组的创建与遍历
数组作为Java中存储和操作一组相同类型数据的基本结构,其创建和遍历是编程基础中的基础。通过不同的创建方式,可以根据实际需求灵活地初始化数组。而选择合适的遍历方法,则可以提高代码的可读性和效率。掌握这些基本技能,对于深入学习Java乃至其他编程语言的数据结构和算法都是至关重要的。
35 6
|
3月前
|
存储 Java 程序员
【一步一步了解Java系列】:何为数组,何为引用类型
【一步一步了解Java系列】:何为数组,何为引用类型
39 1
|
3月前
|
存储 XML Java
如何在 Java 中将常见文档转换为 PNG 图像数组
如何在 Java 中将常见文档转换为 PNG 图像数组
25 1
|
3月前
|
存储 安全 Java
Java数组(Arrays)详解
Java 中的数组是一种用于存储固定数量同类型数据的高效数据结构,支持连续内存存储和随机访问。数组可以声明并初始化,通过索引访问和修改元素,获取长度,使用循环遍历,支持多维形式,并可通过 `Arrays` 类的方法进行复制和排序。数组具有固定大小和类型安全的特点,但需注意越界等问题。灵活运用数组能显著提升编程效率。
154 9
|
4月前
|
存储 Java 数据处理
Java 数组的高级用法
在 Java 中,数组不仅可以存储同类型的数据,还支持多种高级用法,如多维数组(常用于矩阵)、动态创建数组、克隆数组、使用 `java.util.Arrays` 进行排序和搜索、与集合相互转换、增强 for 循环遍历、匿名数组传递以及利用 `Arrays.equals()` 比较数组内容。这些技巧能提升代码的灵活性和可读性,适用于更复杂的数据处理场景。
48 10