JAVA学习Day5【数组】

糖逗

学习视频：https://www.bilibili.com/video/BV17J411G72L?p=20

85-101

1. /*
   
2. *数组(有限个类型相同的变量)
   
3. */
   
4. 
   
5. class test05_01{
   
6.         public static void mian(String[] args){
   
7.                 int[] scores = new int[2];//声明数组
   
8.                 scores[0] = 99;
   
9.                 scores[1] = 100;
   
10.                 //打印数组的长度
    
11.                 System.out.println(scores.length);
    
12.         }
    
13. }
    
14. 
    
15. /*
    
16. *数组初始化（1）动态初始化（2）静态初始化
    
17. */
    
18. 
    
19. 
    
20. class test05_02{
    
21.         public static void main(String[] args){
    
22.                 int[] scores;
    
23.                 //静态初始化
    
24.                 scores = new int[]{33, 45, 11, 87, 99, 100};
    
25.                 //遍历数组
    
26.                 for(int i = 0; i < scores.length; i++){
    
27.                         System.out.println(scores[i]);
    
28.                 }
    
29.                
    
30. 
    
31.         }
    
32. }
    
33. 
    
34. /*
    
35. *静态数组内存
    
36. *int[] array = {1, 3, 4, 5};其中int[]是一种数据类型，数组类型，它是一种引用数据类型
    
37. *引用，表示引用一个对象，引用堆中的一块内存
    
38. *java程序是在JVM中运行的，JVM中的内存主要有两块区域：栈和堆
    
39. *其中栈存储局部变量（现在见到的变量都是局部变量）堆中存储的是对象
    
40. *array是引用数据类型，表示引用堆中这个对象的变量，数组名中存储的是数组的首地址
    
41. *
    
42. *1.数组下标为什么从0开始？下标表示的是这个元素的位置距离首地址的偏移量
    
43. *2.数组名中存储的是什么？数组名中存储的是数组在堆中的一整块区域的首地址
    
44. *3.数组的元素如何存储？在堆中依此连续的存储
    
45. */
    
46. class test05_03{
    
47.         public static void main(String[] args){
    
48.                 int[] array = {1, 3, 4, 5};
    
49.                 System.out.println(array);
    
50.                 //返回的结果是 数组对象的类型@对象的hashCode编码值
    
51. 
    
52.         }
    
53. }
    
54. 
    
55. 
    
56. /*
    
57. *动态初始化(1)如果没有手动赋值之前，数组的元素有默认值
    
58. *元素是基本数据类型
    
59. *byte，short，int，long：0
    
60. *float，double:0.0
    
61. *char:\u0000 字符编码为0的空字符
    
62. *boolean:false
    
63. *元素是引用数据类型：null
    
64. */
    
65. 
    
66. class test05_04{
    
67.         public static void main(String[] args){
    
68.                 char[] letters;
    
69.                 letters = new char[26];
    
70.                 for(int i = 0; i < letters.length; i++){
    
71.                         letters[i] = (char)('A' + i);
    
72.                 }
    
73. 
    
74.         }
    
75. }
    
76. 
    
77. /*
    
78. *数组初始化存储（动态数组）栈存储首地址
    
79. */
    
80. 
    
81. class test05_05{
    
82.         public static void main(String[] args){
    
83.                 int[] array = {1, 5, 7};
    
84.                 //最大值，最小值
    
85.                 int max = array[0];
    
86.                 for(int i = 1; i < array.length; i++){
    
87.                         if(array[i] > max)max = array[i];
    
88.                 }
    
89.                 System.out.println("最大值是:" + max);
    
90.         }
    
91. }
    
92. 
    
93. /*
    
94. *数组反转(原地址不变)
    
95. */
    
96. class test05_06{
    
97.         public static void main(String[] args){
    
98.                 //(1)建立一个新数组，逆序赋值
    
99.                 char[] newLetter = new char[letters.length];
    
100.                 for(int i = 0; i < newLetter.length; i++){
     
101.                         newLetter[i] = Letter[letters.length - 1 - i];
     
102.                 }
     
103.                 letters = newLetter;
     
104.                 for(int i = 0; i < letters.size(); i++){
     
105.                         System.out.println(letters[i]);
     
106.                 }
     
107.                 //(2)首尾互换
     
108.                 for(int i = 0; i < lettes.length / 2; i++){
     
109.                         char temp = letters[i];
     
110.                         letters[i] = letters[letters.length - 1 - i];
     
111.                         letters[letters.length - 1 - i] = temp;
     
112.                 }
     
113.         }
     
114. }
     
115. 
     
116. 
     
117. /*
     
118. *数组复制
     
119. */
     
120. 
     
121. class test05_07{
     
122.         public static void main(String[] args){
     
123.                 //（1）复制一个和原来一样的数组，长度和元素
     
124.                 int[] arr = {1, 2, 3, 4};
     
125.                 int[] newArr = new int[arr.length];
     
126.                 for(int i = 0; i < newArr.length; i++){
     
127.                         newArr[i] = arr[i];
     
128.                 }
     
129.                 //（2）赋值一个比原来数组短的(截取)
     
130.                 int[] newArr = new int[end - start + 1];
     
131.                 for(int i = 0; i < newArr.length; i++){
     
132.                         newArr[i] = arr[start + i];
     
133.                 }
     
134.                 //（3）复制一个比原来常的
     
135.                 int[] newAR = new int[arr.length * 2];
     
136.                 for(int i = 0; i < arr.length; i++){
     
137.                         newArr[i] = arr[i];
     
138.                 }
     
139.                 //（4）复制一个新数组，新数组的长度有键盘输入，长度不定
     
140.                 java.util.Scanner input = new java.util.Scanner(System.in);
     
141.                 System.out.print("请输入新数组的长度：");
     
142.                 int len = input.nextInt();
     
143.                 int[] newArr = new int[len];
     
144.                 for(int i = 0; i < arr.length && i < newArr.length; i++){
     
145.                         newArr[i] = arr[i]
     
146.                 }
     
147.         }
     
148. }
     
149. 
     
150. 
     

复制代码