Artikel ini membawakan anda pengetahuan yang berkaitan tentang java Ia terutamanya mengatur isu yang berkaitan dengan definisi dan penggunaan tatasusunan, termasuk tatasusunan String dalam kaedah utama dan penyimpanan data rujukan dalam tatasusunan Mari lihat jenis, pengembangan dan penyalinan tatasusunan, dsb. Saya harap ia akan membantu semua orang.
Pembelajaran yang disyorkan: "tutorial video java"
Tatasusunan dalam bahasa Java ialah jenis data rujukan ; ia bukan jenis data asas; Susun atur sebenarnya ialah bekas yang boleh memuatkan berbilang elemen pada masa yang sama. (Suatu tatasusunan ialah koleksi data) Tatasusunan: secara literal bermaksud "satu set data"
Tatasusunan boleh menyimpan data "jenis data asas" dan data "jenis data rujukan".
Oleh kerana tatasusunan ialah jenis rujukan, objek tatasusunan berada dalam ingatan timbunan
. (Array disimpan dalam timbunan) Jika "objek java" disimpan dalam tatasusunan, apa yang sebenarnya disimpan ialah "rujukan (alamat memori)
" objek objek Java tatasusunan tidak boleh disimpan secara langsung (simpan alamatnya).
Bagaimana untuk mengisytiharkan/mentakrif tatasusunan satu dimensi?Setelah tatasusunan dibuat, ia dinyatakan dalam java bahawa panjangnya tidak boleh diubah . (Panjang tatasusunan tidak berubah)Pengkelasan tatasusunan: tatasusunan satu dimensi, tatasusunan dua dimensi, tatasusunan tiga dimensi, tatasusunan berbilang dimensi... (tatasusunan satu dimensi adalah lebih biasa, dua dimensi tatasusunan kadangkala digunakan!)
Semua objek tatasusunan mempunyai
atribut panjang (disertakan dalam java), yang digunakan untuk mendapatkan bilangan elemen dalam tatasusunan. Tatasusunan
dalam Java memerlukan elemen dalam tatasusunan mempunyai jenis yang sama . Sebagai contoh, tatasusunan jenis int hanya boleh menyimpan jenis int, dan tatasusunan jenis Orang hanya boleh menyimpan jenis Orang. Contohnya: apabila membeli-belah di pasar raya, anda hanya boleh meletakkan epal dalam beg beli-belah anda, bukan epal dan oren pada masa yang sama. (Jenis elemen yang disimpan dalam tatasusunan adalah seragam) Apabila tatasusunan disimpan dalam ingatan, alamat memori unsur-unsur dalam tatasusunan (setiap elemen yang disimpan selalu disusun bersebelahan antara satu sama lain) adalah berterusan. Alamat memori adalah berturut-turut. Ini ialah ciri (ciri) tatasusunan yang menyimpan elemen. Array sebenarnya adalah struktur data yang mudah. Untuk semua tatasusunan, "alamat memori kotak kecil pertama" digunakan sebagai alamat memori bagi keseluruhan objek tatasusunan. (Alamat memori bagi elemen pertama dalam tatasusunan digunakan sebagai alamat memori bagi keseluruhan objek tatasusunan.)
Setiap elemen dalam tatasusunan mempunyai subskrip dan subskrip bermula dari 0 dan meningkat sebanyak 1. Subskrip elemen terakhir ialah: panjang - 1; subskrip adalah sangat penting, kerana apabila kita "mengakses" elemen dalam tatasusunan, kita perlu menggunakan subskrip.
Array
Apakah kelebihan dan keburukan struktur data ini? Kelebihan
: Ia amat cekap apabila membuat pertanyaan/mencari/mendapatkan semula elemen pada subskrip tertentu. Ia boleh dikatakan sebagai struktur data dengan kecekapan pertanyaan tertinggi. Mengapa kecekapan mendapatkan semula begitu tinggi? Pertama: Alamat memori setiap elemen adalah berterusan dari segi storan ruang.
Kedua: Setiap elemen adalah daripada jenis yang sama, jadi ia mengambil ruang yang sama.
Ketiga: Mengetahui alamat memori elemen pertama, saiz ruang yang diduduki oleh setiap elemen dan subskrip, supaya anda boleh mengira elemen di atas subskrip tertentu melalui alamat memori ungkapan matematik .
Cari elemen terus melalui alamat memori, jadi kecekapan mendapatkan tatasusunan adalah yang tertinggi. Apabila 100 elemen disimpan dalam tatasusunan, atau 1 juta elemen disimpan, kecekapan adalah sama dari segi pertanyaan/pendapatan elemen, kerana elemen dalam tatasusunan tidak dicari satu demi satu, tetapi dikira melalui ungkapan matematik. (Kira alamat memori dan cari terus.) Kelemahan
: Pertama: Untuk memastikan alamat memori setiap elemen dalam tatasusunan berterusan, elemen dipadam atau ditambah secara rawak kepada tatasusunan Kadangkala, kecekapan adalah rendah, kerana penambahan dan pemadaman elemen secara rawak akan melibatkan operasi anjakan seragam ke hadapan atau ke belakang bagi elemen berikutnya. Kedua: Tatasusunan tidak boleh menyimpan sejumlah besar data Mengapa? Kerana sukar untuk mencari ruang ingatan berterusan yang sangat besar dalam ruang ingatan. Tiada kesan kecekapan pada penambahan atau pemadaman elemen terakhir dalam tatasusunan.
Format tatabahasa:int[] array1; double[] array2; boolean[] array3; String[] array4; Object[] array5;Bagaimana untuk memulakan tatasusunan satu dimensi?
Termasuk dua kaedah: pemulaan statik tatasusunan satu dimensi dan pemulaan dinamik tatasusunan satu dimensi.
(1)Format sintaks permulaan statik:
tatasusunan int[] = {100, 2100, 300, 55};
(2) Format sintaks permulaan dinamik:
tatasusunan int[] = new int[5];5 di sini mewakili bilangan elemen dalam tatasusunan.
Mulakan tatasusunan jenis int 5 panjang, setiap elemen mempunyai nilai lalai 0
Contoh lain: String[] names = new String[6];Initialization 6 Tatasusunan jenis rentetan panjang, dengan nilai lalai setiap elemen adalah nol.
Bila hendak menggunakan pemula tatasusunan statik? Bila hendak menggunakan inisialisasi tatasusunan dinamik?
(1) Apabila mencipta tatasusunan kunci, apabila menentukan elemen tertentu yang disimpan dalam tatasusunan, gunakan pemulaan statik
(2) Apabila mencipta tatasusunan kunci, tidak pasti data apa akan disimpan pada masa hadapan , anda boleh menggunakan permulaan dinamik untuk pra-peruntukkan ruang memori
package com.bjpowernode.javase.array;
public class ArrayTest01 {
public static void main(String[] args) {
//1.静态初始化
int[] a1 = {1,3,5,7,9};
//所有的数组对象都有length属性，而不是方法！
System.out.println("数组元素的个数是："+a1.length);
//取第一个元素
System.out.println(a1[0]);
//取最后一个元素
System.out.println(a1[a1.length-1]);
//改数据
a1[a1.length-1] = 0;
//遍历数据
for(int i=0;i< a1.length;i++){
System.out.println(a1[i]);
}
//数据下标越界异常，例如：访问下面为6的数据元素
//System.out.println(a1[6]);// ArrayIndexOutOfBoundsException
//2.动态初始化
int[] a2 = new int[5]; //默认值是0
for(int i=0;i< a2.length;i++){
System.out.println(a2[i]);
}
//初始化一个Object类型的数组，
//1.采用静态初始化方式
Object o1 = new Object();
Object o2 = new Object();
Object o3 = new Object();
Object[] object = {o1,o2,o3};
//上面就等价于：Object[] object = {new Object(),new Object(),new Object()};
for(int i=0;i<object.length;i++){
System.out.println(object[i]);// 默认调用toString方法
}
//2.采用动态初始化的方式
Object[] obj = new Object[3];
for(int i=0;i<obj.length;i++){
System.out.println(obj[i]);// null null null
}
//初始化一个String类型的数组
//1.静态初始化
String[] str1 = {"abc","bcd","cde"};
for (int i = 0; i < str1.length; i++) {
System.out.println(str1[i]);
}
//2.动态初始化
String[] str2 = new String[3];
for (int i = 0; i < str2.length; i++) {
System.out.println(str2[i]);
}
}
}Peta memori storan dinamik
Apabila tatasusunan diluluskan, kaedah itu juga menerimanya dalam bentuk tatasusunan ini; statik atau dibuat secara dinamik; dan Kami menulis kaedahsebagai statik, supaya boleh dipanggil tanpa memerlukan objek baharu!
Contoh 1:
package com.bjpowernode.javase.array;
public class ArrayTest02 {
//也可以采用C++的风格,写成String args[]
public static void main(String args[]) {
System.out.println("HelloWorld");
// 1.方法的参数传数组---静态初始化方式
int[] a = {1,2,3,4,5};
printArray(a);
// 2.方法的参数传数组---动态初始化方式
int[] arr = new int[5];
printArray(arr);
// 直接一步完成
printArray(new int[3]);
}
//静态方法进行打印
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}Contoh 2: (Guru)
(1 ) Kes khas menghantar tatasusunan statik jika anda menghantar tatasusunan statik secara langsung, sintaks mesti ditulis seperti ini! (2) Mari kita lihat contoh dahulu:int[] arr = {1,2,3}; Apabila kita lulus parameter tatasusunan, kita biasanya menghantar nama tatasusunan arr, contohnya: printArray(arr); Tetapi cara lain ialah dengan menghantarnya dan mengalih keluar komponen baki nama tatasusunan arr:
int[]{1,2,3} , tetapi tambah kata kunci baharu, contohnya:printArray(new int[]{1,2,3});
package com.bjpowernode.javase.array;
public class ArrayTest03 {
public static void main(String[] args) {
//----------1.动态初始化一位数组（两种传参方式）
//第一种传参方式
int[] a1 = new int[5];//默认是5个0
printArray(a1);
System.out.println("-------------");
//第二种传参方式
printArray(new int[3]);
System.out.println("-------------");
//----------2.静态初始化一位数组（两种传参方式）
//第一种传参方式
int[] a2 = {1,2,3};
printArray(a2);
System.out.println("-------------");
//第二种传参方式----直接传递一个静态数组
printArray(new int[]{4,5,6});
}
//调用的静态方法----静态方法比较方便，不需要new对象
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}String in kaedah utama Array (1) Untuk main(String[] args): siapa yang bertanggungjawab untuk memanggil kaedah utama (JVM)
Apabila JVM memanggil utama kaedah, ia secara automatik akan melepasi tatasusunan String masuk, panjangnya ialah 0.
Contoh 1:
package com.bjpowernode.javase.array;
public class ArrayTest04 {
// 这个方法程序员负责写出来，JVM负责调用。JVM调用的时候一定会传一个String数组过来。
public static void main(String[] args) {
// JVM默认传递过来的这个数组对象的长度？默认是0
// 通过测试得出：args不是null。
System.out.println("JVM给传递过来的String数组参数，它这个数组的长度是？"
+ args.length); //0
// 以下这一行代码表示的含义：数组对象创建了，但是数组中没有任何数据。就等价于：
String[] strs = new String[0]; //动态的方式
//String[] strs = {}; // 静态初始化数组，里面没东西。
printLength(strs); //调用printLength静态方法
/*
既然传过来的“String[] args”数组里什么都没有；那么这个数组什么时候里面会有值呢？
其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为“String[] args”
例如这样运行程序：java ArrayTest04 abc def xyz；相当于在编译时进行传参
那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中。
所以main方法上面的String[] args数组主要是用来接收用户输入参数的。
把abc def xyz 转换成字符串数组：{"abc","def","xyz"}
*/
// 遍历数组
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
//既然是编译时进行传参，对于编译运行一体的IDEA怎么使用呢？
//Run--->EditConfiguration--->Program Arguments里面进行传参，然后在从后重新运行
}
public static void printLength(String[] args){
System.out.println(args.length); // 0
}
}
Contoh 2:
(1 ) Apakah kegunaan "String[] args" di atas kaedah utama?boleh digunakan untuk mensimulasikan sistem log masuk ! Sila lihat contoh menarik berikut:
package com.bjpowernode.javase.array;
/*
模拟一个系统，假设这个系统要使用，必须输入用户名和密码。
*/
public class ArrayTest05 {
public static void main(String[] args) {
//先判断长度，是不是两个字符串长度，不是2直接终止程序
if(args.length != 2){
System.out.println("请输入用户名和密码");
return;
}
//取出用户名和密码
String username = args[0];
String password = args[1];
// 假设用户名是admin，密码是123的时候表示登录成功。其它一律失败。
// 判断两个字符串是否相等，需要使用equals方法。
// if(username.equals("admin") && password.equals("123")){ //这样有可能空指针异常
// 下面这种编写方式，也可以避免空该指针异常!
if("admin".equals(username) && "123".equals(password)){
System.out.println("恭喜你，登录成功");
System.out.println("您可以继续使用该系统");
}else{
System.out.println("账户或密码错误，请重新输入");
}
}
}
Menyimpan jenis data rujukan dalam tatasusunan (titik utama)
(1) Satu- tatasusunan dimensi Secara mendalam: Jenis yang disimpan dalam tatasusunan ialah:Jenis data rujukan; untuk tatasusunan, sebenarnya hanya "alamat memori" objek Java boleh disimpan. Setiap elemen yang disimpan dalam tatasusunan ialah "rujukan" . Contoh soalan berikut berfokus pada pemahaman!
(2)Tatasusunan memerlukan jenis elemen seragam dalam tatasusunan; tetapi juga boleh menyimpan subjenisnya !
package com.bjpowernode.javase.array;
public class ArrayTest06 {
public static void main(String[] args) {
//1.静态创建一个Animal类型的数组
Animal a1 = new Animal();
Animal a2 = new Animal();
Animal[] animals = {a1,a2};
//对Animal数组进行遍历
for (int i = 0; i < animals.length; i++) {
//方法1
/*Animal a = animals[i];
a.move();*/
//方法2
animals[i].move();
}
//2.动态初始化一个长度为2的animal类型的数组
Animal[] ans = new Animal[2];
ans[0] = new Animal();
//ans[1] = new Product(); //err，Product和Animals没有任何关系
//Animal数组中只能存放Animal类型，不能存放Product类型
//3.Animal数组中可以存放Cat类型的数据，因为Cat是Animal一个子类
ans[1] = new Cat();
for (int j = 0; j < ans.length; j++) {
ans[j].move();
}
//4.创建一个Animal类型的数据，数组当中存储Cat和Bird
//4.1静态创建
Cat cat = new Cat();
Bird bird = new Bird();
Animal[] anim = {cat,bird};
for (int i = 0; i < anim.length; i++) {
//直接调用子类和父类都有的move()方法
//anim[i].move();
//这里想要调用子类Bird里面特有的方法，需要向下转型
if(anim[i] instanceof Bird){
Bird b = (Bird)anim[i]; //向下转型
b.move();
b.sing(); //调用子类特有的方法
}else{
anim[i].move();
}
}
}
}
//动物类
class Animal{
public void move(){
System.out.println("Animals move.....");
}
}
//商品类
class Product{
}
//有一个猫类继承动物类
class Cat extends Animal{
public void move(){
System.out.println("Cat move.....");
}
}
//有一个鸟类继承动物类
class Bird extends Animal{
public void move(){
System.out.println("Bird move.....");
}
//鸟特有的方法
public void sing(){
System.out.println("鸟儿在歌唱！");
}
}Peluasan dan penyalinan tatasusunan
Dalam pembangunan Java, setelah panjang tatasusunan ditentukan untuk tidak berubah, apakah yang perlu saya lakukan jika tatasusunan itu penuh dan perlu diperluaskan?(1) Pengembangan
(3)
tatasusunan dalam Java ialah: mula-mula buat tatasusunan berkapasiti besar, dan kemudian salin elemen dalam tatasusunan berkapasiti kecil ke tatasusunan besar satu demi satu. Kapasiti kecil akan dikeluarkan. (2) Kesimpulan:
Kecekapan pengembangan tatasusunan adalah rendah. Kerana ia melibatkan isu penyalinan. Jadi sila beri perhatian dalam pembangunan masa hadapan: salin tatasusunan sesedikit mungkin. Anda boleh menganggarkan panjang yang sesuai di bawah apabila mencipta objek tatasusunan Adalah lebih baik untuk menganggarkan dengan tepat, yang boleh mengurangkan bilangan pengembangan tatasusunan. Tingkatkan kecekapan.Gunakan System.arraycopy untuk menyalin , sejumlah 5 parameter; salinan untuk disalin)
package com.bjpowernode.javase.array;
public class ArrayTest07 {
public static void main(String[] args) {
//java中的数组是怎样拷贝的呢？System.arraycopy(5个参数)
//System.arraycopy(源,下标,目的地,下标,个数)
//拷贝源---把3、5、7拷贝过去
int[] src = {1,3,5,7,9};
//拷贝目的地---拷贝到下标为5的地方
int[] dest = new int[20];
//调用拷贝函数
System.arraycopy(src,1,dest,5,3);
//打印验证
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]+" ");
}
//拷贝引用数据类型
String[] str = {"hello","world"};
String[] strs = new String[10];
System.arraycopy(str,0,strs,3,2);
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
System.out.println("--------------");
//采用动态开辟的时候拷贝的是地址
Object[] objs = {new Object(),new Object(),new Object()};
Object[] objects = new Object[5];
System.arraycopy(objs,0,objects,0,3);
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
}
}
内存图
推荐学习：《java视频教程》
Atas ialah kandungan terperinci Mari kita bincangkan tentang definisi dan penggunaan tatasusunan dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!