ජාවා අරාව මුද්‍රණය කිරීමේ සරලම ක්‍රමය කුමක්ද?

ජාවා හි, අරා අභිබවා නොයනු ඇත toString(), එබැවින් ඔබ කෙලින්ම මුද්‍රණය කිරීමට උත්සාහ කරන්නේ නම්, ඔබට අර්ථ දක්වා ඇති පරිදි අරාවෙහි classNameහෙක්ස් + '@' + hashCodeලැබේ Object.toString().

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);     // prints something like '[I@3343c8b3'

නමුත් සාමාන්‍යයෙන් අපට අවශ්‍ය වන්නේ ඊට වඩා වැඩි යමක් [1, 2, 3, 4, 5]. එය කළ හැකි සරලම ක්‍රමය කුමක්ද? ආදාන සහ ප්‍රතිදානයන් සඳහා උදාහරණ කිහිපයක් මෙන්න:

// Array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};
//output: [1, 2, 3, 4, 5]

// Array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};
//output: [John, Mary, Bob]

ජාවා 5 සිට ඔබට අරා තුළ Arrays.toString(arr)හෝ Arrays.deepToString(arr)අරා සඳහා භාවිතා කළ හැකිය . Object[]අනුවාදය .toString()අරාවෙහි ඇති සෑම වස්තුවකටම කතා කරන බව සලකන්න . ප්‍රතිදානය ඔබ ඉල්ලන ආකාරයටම සරසා ඇත.

උදාහරණ:

• සරල අරාව:

  String[] array = new String[] {"John", "Mary", "Bob"};
  System.out.println(Arrays.toString(array));

  ප්‍රතිදානය:

  [John, Mary, Bob]

• නෙස්ටඩ් අරා:

  String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}};
  System.out.println(Arrays.toString(deepArray));
  //output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
  System.out.println(Arrays.deepToString(deepArray));

  ප්‍රතිදානය:

  [[John, Mary], [Alice, Bob]]

• double අරාව:

  double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 };
  System.out.println(Arrays.toString(doubleArray));

  ප්‍රතිදානය:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int අරාව:

  int[] intArray = { 7, 9, 5, 1, 3 };
  System.out.println(Arrays.toString(intArray));

  ප්‍රතිදානය:

  [7, 9, 5, 1, 3 ]

සෑම විටම පළමුව සම්මත පුස්තකාල පරීක්ෂා කරන්න.

import java.util.Arrays;

ඉන්පසු උත්සාහ කරන්න:

System.out.println(Arrays.toString(array));

හෝ ඔබේ අරාවෙහි වෙනත් අරා මූලද්‍රව්‍ය ලෙස අඩංගු වේ නම්:

System.out.println(Arrays.deepToString(array));

කෙසේ වෙතත්, මෙය දැන ගැනීම සතුටක්, කෙසේ වෙතත් “සෑම විටම පළමුව සම්මත පුස්තකාල පරීක්ෂා කරන්න” මම කිසි විටෙකත් උපක්‍රමයට පැටලෙන්නේ නැත Arrays.toString( myarray )

- මෙය සිදු කරන්නේ කෙසේදැයි බැලීමට මම මයිරේ වර්ගය කෙරෙහි අවධානය යොමු කළෙමි. මට කාරණය හරහා නැවත කියවීමට අවශ්‍ය නොවීය: සූර්යග්‍රහණ නිදොස්කරණය සහ myarray.toString () හි මා දකින දෙයට සමානව එය පිටතට ගෙන ඒමට මට පහසු ඇමතුමක් අවශ්‍ය විය.

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );

JDK1.8 හි ඔබට සමස්ත මෙහෙයුම් සහ ලැම්බඩා ප්‍රකාශනයක් භාවිතා කළ හැකිය:

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

// #3
Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob
*/

ජාවා 8 සිට ඇරඹෙන කෙනෙකුට වරහන් නොමැතිව අරා මූලද්‍රව්‍ය මුද්‍රණය කිරීම join()සඳහා සංගීත පන්තිය විසින් ලබා දී ඇති ක්‍රමයේ වාසිය ලබා ගත හැකි අතර තේරීමේ පරිමිතියකින් වෙන් කරනු ලැබේ (පහත උදාහරණය සඳහා අවකාශයේ අක්‍ෂරය මෙයයි):

String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting) 

ප්‍රතිදානය "හේයි අමිගෝ!"

ඔබ ජාවා 1.4 භාවිතා කරන්නේ නම්, ඔබට ඒ වෙනුවට කළ හැකිය:

System.out.println(Arrays.asList(array));

(මෙය 1.5+ කින් ද ක්‍රියා කරයි.)

Arrays.toString

සෘජු පිළිතුරක් ලෙස, @Esko ඇතුළු කිහිප දෙනෙකු විසින් ලබා දී ඇති විසඳුම භාවිතා, Arrays.toStringහා Arrays.deepToStringක්රම, හොඳම හුදෙක් වේ.

ජාවා 8 - Stream.collect (බැඳීම ()), Stream.forEach

පහත මම යෝජනා කර ඇති වෙනත් ක්‍රම කිහිපයක් ලැයිස්තුගත කිරීමට උත්සාහ කරමි, ටිකක් වැඩිදියුණු කිරීමට උත්සාහ කරමි, වඩාත්ම කැපී පෙනෙන එකතු කිරීම වන්නේ Stream.collectක්‍රියාකරු භාවිතා කිරීම , a භාවිතා කිරීම , කරන්නේ කුමක්ද යන්න අනුකරණය කිරීමයි.joining CollectorString.join

int[] ints = new int[] {1, 2, 3, 4, 5};
System.out.println(IntStream.of(ints).mapToObj(Integer::toString).collect(Collectors.joining(", ")));
System.out.println(IntStream.of(ints).boxed().map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(ints));

String[] strs = new String[] {"John", "Mary", "Bob"};
System.out.println(Stream.of(strs).collect(Collectors.joining(", ")));
System.out.println(String.join(", ", strs));
System.out.println(Arrays.toString(strs));

DayOfWeek [] days = { FRIDAY, MONDAY, TUESDAY };
System.out.println(Stream.of(days).map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(days));

// These options are not the same as each item is printed on a new line:
IntStream.of(ints).forEach(System.out::println);
Stream.of(strs).forEach(System.out::println);
Stream.of(days).forEach(System.out::println);

ජාවා 8 ට පෙර

අපට Arrays.toString(array)එක් මාන මානක සහ Arrays.deepToString(array)බහු-මාන අරා මුද්‍රණය කිරීමට භාවිතා කළ හැකිය .

ජාවා 8

දැන් අපි එම විකල්පය වෙලා තිබෙනවා Streamසහ lambdaඅරාව මුද්රණය කිරීමට.

මුද්‍රණය එක් මාන මාන:

public static void main(String[] args) {
    int[] intArray = new int[] {1, 2, 3, 4, 5};
    String[] strArray = new String[] {"John", "Mary", "Bob"};

    //Prior to Java 8
    System.out.println(Arrays.toString(intArray));
    System.out.println(Arrays.toString(strArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(intArray).forEach(System.out::println);
    Arrays.stream(strArray).forEach(System.out::println);
}

ප්‍රතිදානය:

[1, 2, 3, 4, 5]
[ජෝන්, මේරි, බොබ්]
1
2
3
4
5
ජෝන්
මේරි
බොබ්

මුද්රණ බහු-මාන Array අපි භාවිතා කළ හැකි බහු-මාන අරා මුද්රණය කිරීමට අවශ්ය යන්තම් නඩුව Arrays.deepToString(array)ලෙස:

public static void main(String[] args) {
    int[][] int2DArray = new int[][] { {11, 12}, { 21, 22}, {31, 32, 33} };
    String[][] str2DArray = new String[][]{ {"John", "Bravo"} , {"Mary", "Lee"}, {"Bob", "Johnson"} };

    //Prior to Java 8
    System.out.println(Arrays.deepToString(int2DArray));
    System.out.println(Arrays.deepToString(str2DArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(int2DArray).flatMapToInt(x -> Arrays.stream(x)).forEach(System.out::println);
    Arrays.stream(str2DArray).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
} 

දැන් නිරීක්ෂණය කළ යුතු කරුණ නම් Arrays.stream(T[]), int[]අප වෙත ආපසු ලබා දෙන Stream<int[]>ක්‍රමවේදය, flatMapToInt()එක් එක් මූලද්‍රව්‍යයට ලබා දී ඇති සිතියම්කරණ ශ්‍රිතය යෙදීමෙන් නිපදවන ලද සිතියම්ගත කළ ධාරාවක අන්තර්ගතය සමඟ එක් එක් ප්‍රවාහයේ මූලද්‍රව්‍ය සිතියම් ගත කිරීමයි.

ප්‍රතිදානය:

[[11, 12], [21, 22], [31, 32, 33]]
[[ජෝන්, බ්‍රාවෝ], [මේරි, ලී], [බොබ්, ජොන්සන්]]
11
12
21
22
31
32
33
ජෝන්
බ්‍රාවෝ
මේරි
ලී
බොබ්
ජොන්සන්

Arrays.deepToString(arr) එක් පේළියක පමණක් මුද්‍රණය කරයි.

int[][] table = new int[2][2];

ද්විමාන වගුවක් ලෙස මුද්‍රණය කිරීම සඳහා ඇත්ත වශයෙන්ම වගුවක් ලබා ගැනීමට, මට මෙය කිරීමට සිදු විය:

System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));

Arrays.deepToString(arr)ක්‍රමය බෙදුම්කරු නූලක් ගත යුතු බව පෙනේ , නමුත් අවාසනාවකට එය එසේ නොවේ.

for(int n: someArray) {
    System.out.println(n+" ");
}

ජාවා හි අරා මුද්‍රණය කිරීමට විවිධ ක්‍රම:

1. සරල මාර්ගය

   List<String> list = new ArrayList<String>();
   list.add("One");
   list.add("Two");
   list.add("Three");
   list.add("Four");
   // Print the list in console
   System.out.println(list);

ප්‍රතිදානය: [එක, දෙක, තුන, හතර]

2. භාවිතා කිරීම toString()

   String[] array = new String[] { "One", "Two", "Three", "Four" };
   System.out.println(Arrays.toString(array));

ප්‍රතිදානය: [එක, දෙක, තුන, හතර]

3. අරා අරා මුද්‍රණය කිරීම

   String[] arr1 = new String[] { "Fifth", "Sixth" };
   String[] arr2 = new String[] { "Seventh", "Eight" };
   String[][] arrayOfArray = new String[][] { arr1, arr2 };
   System.out.println(arrayOfArray);
   System.out.println(Arrays.toString(arrayOfArray));
   System.out.println(Arrays.deepToString(arrayOfArray));

ප්‍රතිදානය: [[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1, [Ljava.lang.String; @ 42719c] [[පස්වන, හයවන], [හත්වන, අටවන]]

සම්පත්: අරාවකට ප්‍රවේශ වන්න

මගේ මතය අනුව අරාව මුද්‍රණය කිරීමේ සරලම ක්‍රමය වන්නේ ලූප සඳහා නිතිපතා භාවිතා කිරීමයි. මෙන්න ඔබේ intArray මත පදනම්ව නියැදි කේතයක් ඇත

for (int i = 0; i < intArray.length; i++) {
   System.out.print(intArray[i] + ", ");
}

එය ඔබගේ 1, 2, 3, 4, 5 ලෙස ප්‍රතිදානය ලබා දෙයි

මට මෑතකදී වැනිලා # ජාවා හි මෙම ලිපිය හමු විය . එය එතරම් පහසු ලිවීමක් නොවේ Arrays.toString(arr);, පසුව java.util.Arrays;සෑම විටම ආනයනය කරයි.

කරුණාකර සටහන් කරන්න, මෙය කිසිසේත් ස්ථිර විසඳුමක් නොවේ. නිදොස් කිරීම සරල කළ හැකි හැක් එකක් පමණි.

අරාවක් මුද්‍රණය කිරීමෙන් සෘජුවම අභ්‍යන්තර නිරූපණය සහ හැෂ් කේතය ලැබේ. දැන්, සියලුම පංතිවල Objectමව් වර්ගය ලෙස ඇත. ඉතින්, ඇයි හැක් නොකරන්නේ Object.toString()? වෙනස් කිරීමකින් තොරව, වස්තු පන්තිය මේ ආකාරයෙන් පෙනේ:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

මෙය වෙනස් කරන්නේ නම් කුමක් කළ යුතුද:

public String toString() {
    if (this instanceof boolean[])
        return Arrays.toString((boolean[]) this);
    if (this instanceof byte[])
        return Arrays.toString((byte[]) this);
    if (this instanceof short[])
        return Arrays.toString((short[]) this);
    if (this instanceof char[])
        return Arrays.toString((char[]) this);
    if (this instanceof int[])
        return Arrays.toString((int[]) this);
    if (this instanceof long[])
        return Arrays.toString((long[]) this);
    if (this instanceof float[])
        return Arrays.toString((float[]) this);
    if (this instanceof double[])
        return Arrays.toString((double[]) this);
    if (this instanceof Object[])
        return Arrays.deepToString((Object[]) this);
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

විධාන රේඛාවට පහත සඳහන් දෑ එකතු කිරීමෙන් මෙම නවීකරණය කරන ලද පන්තිය පන්ති මාවතට එක් කළ හැකිය : -Xbootclasspath/p:target/classes.

දැන්, deepToString(..)ජාවා 5 සිට ලබා ගත හැකි බැවින්, වෙනත් අරා අඩංගු අරා සඳහා සහය එක් කිරීම සඳහා toString(..)පහසුවෙන් වෙනස් කළ හැකිය deepToString(..).

මෙය තරමක් ප්‍රයෝජනවත් හැක් එකක් බව මට පෙනී ගිය අතර ජාවාට මෙය සරලව එකතු කළ හැකි නම් එය ඉතා හොඳ වේ. නූල් නිරූපණය ගැටළු සහගත විය හැකි බැවින් ඉතා විශාල අරා තිබීම සමඟ ඇති විය හැකි ගැටළු මම තේරුම් ගතිමි. සමහර විට එවැනි සිදුවීම් සඳහා a System.outහෝ a වැනි දෙයක් සම්මත කරන්න PrintWriter.

ඔබ භාවිතා කරන ඕනෑම JDK අනුවාදයක් එය සැමවිටම ක්‍රියාත්මක විය යුතුය:

System.out.println(Arrays.asList(array));

Arrayවස්තු අඩංගු නම් එය ක්‍රියා කරයි . Arrayප්‍රාථමික වර්ග අඩංගු නම් , ඔබට ප්‍රාථමිකය කෙලින්ම ගබඩා කිරීම වෙනුවට එතීමේ පන්ති භාවිතා කළ හැකිය ..

උදාහරණයක්:

int[] a = new int[]{1,2,3,4,5};

එය ආදේශ කරන්න:

Integer[] a = new Integer[]{1,2,3,4,5};

යාවත්කාලීන කිරීම:

ඔව් ! මෙය සඳහන් කළ යුත්තේ, අරාව වස්තු අරාවකට පරිවර්තනය කිරීම හෝ වස්තුවේ අරාව භාවිතා කිරීම මිල අධික වන අතර එය ක්‍රියාත්මක කිරීම මන්දගාමී විය හැකි බැවිනි. එය සිදුවන්නේ ඔටෝ බොක්සිං ලෙස හඳුන්වන ජාවා ස්වභාවය අනුව ය.

එබැවින් මුද්‍රණ කටයුතු සඳහා පමණක් එය භාවිතා නොකළ යුතුය. පරාමිතියක් ලෙස අරාව ගෙන අපේක්ෂිත ආකෘතිය මුද්‍රණය කරන ශ්‍රිතයක් අපට කළ හැකිය

public void printArray(int [] a){
        //write printing code
} 

ජාවා 8 හි එය පහසුය. මූල පද දෙකක් තිබේ

1. ධාරාව: Arrays.stream(intArray).forEach

2. ක්‍රම යොමුව: ::println

   int[] intArray = new int[] {1, 2, 3, 4, 5};
   Arrays.stream(intArray).forEach(System.out::println);

ඔබ එකම මාර්ගය අරාව සියලු අංග මුද්රණය කිරීමට අවශ්ය නම්, පසුව යන්තම් භාවිතා printවෙනුවට printlnඑනම්

int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);

ක්‍රම යොමුවකින් තොරව තවත් ක්‍රමයක් භාවිතා කරන්න:

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(intArray));

ඔබේ අරාව වර්‍ග වර්ගයේ නම් තවත් එක් ක්‍රමයක් තිබේ []:

char A[] = {'a', 'b', 'c'}; 

System.out.println(A); // no other arguments

මුද්රණ

abc

සියලු පිළිතුරු වලට එකතු කිරීම සඳහා, JSON නූලක් ලෙස වස්තුව මුද්‍රණය කිරීම ද විකල්පයකි.

ජැක්සන් භාවිතා කිරීම:

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));

Gson භාවිතා කිරීම:

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));

ඔබ අරාව හරහා ලූප් කළ හැකිය, ඔබ ලූප් කරන විට එක් එක් අයිතමය මුද්‍රණය කරයි. උදාහරණයක් වශයෙන්:

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

ප්‍රතිදානය:

item 1
item 2
item 3

අරාව මුද්‍රණය කිරීමට පහත ක්‍රම තිබේ

 // 1) toString()  
    int[] arrayInt = new int[] {10, 20, 30, 40, 50};  
    System.out.println(Arrays.toString(arrayInt));

// 2 for loop()
    for (int number : arrayInt) {
        System.out.println(number);
    }

// 3 for each()
    for(int x: arrayInt){
         System.out.println(x);
     }

මම උත්සාහ කළ සරල කෙටිමඟ මෙයයි:

    int x[] = {1,2,3};
    String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
    System.out.println(printableText);

එය මුද්‍රණය වේ

1
2
3

මෙම ප්‍රවේශයේදී ලූප අවශ්‍ය නොවන අතර එය කුඩා අරා සඳහා පමණක් සුදුසු වේ

අරාවෙහි මූලද්‍රව්‍ය මුද්‍රණය කිරීම සඳහා සෑම ලූපයක්ම භාවිතා කළ හැකිය:

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);

public class printer {

    public static void main(String[] args) {
        String a[] = new String[4];
        Scanner sc = new Scanner(System.in);
        System.out.println("enter the data");
        for (int i = 0; i < 4; i++) {
            a[i] = sc.nextLine();
        }
        System.out.println("the entered data is");
        for (String i : a) {
            System.out.println(i);
        }
      }
    }

Org.apache.commons.lang3.StringUtils.join (*) ක්‍රම භාවිතා කිරීම විකල්පයක් විය හැකිය
උදාහරණයක් ලෙස:

String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//output: [John , Mary , Bob]

මම පහත පරායත්තතාවය භාවිතා කළෙමි

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>

මෙය බයිට් එකක් මුද්‍රණය කිරීම සඳහා අනුපිටපතක් ලෙස සලකුණු කර ඇත [] . සටහන: බයිට් අරා සඳහා සුදුසු විය හැකි අතිරේක ක්‍රම තිබේ.

ISO-8859-1 අක්ෂර අඩංගු නම් ඔබට එය නූලක් ලෙස මුද්‍රණය කළ හැකිය.

String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);

හෝ එහි UTF-8 නූලක් තිබේ නම්

String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);

හෝ ඔබට එය ෂඩාස්රාකාර ලෙස මුද්‍රණය කිරීමට අවශ්‍ය නම්.

String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);

හෝ ඔබට එය පදනම් 64 ලෙස මුද්‍රණය කිරීමට අවශ්‍ය නම්.

String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);

හෝ ඔබට අත්සන් කළ බයිට් අගයන් පෙළක් මුද්‍රණය කිරීමට අවශ්‍ය නම්

String s = Arrays.toString(bytes);
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = Byte.parseByte(split[i]);

හෝ අත්සන් නොකළ බයිට් අගයන් පෙළක් මුද්‍රණය කිරීමට ඔබට අවශ්‍ය නම්

String s = Arrays.toString(
               IntStream.range(0, bytes.length).map(i -> bytes[i] & 0xFF).toArray());
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = (byte) Integer.parseInt(split[i]); // might need a range check.

// array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};

System.out.println(Arrays.toString(intArray));

output: [1, 2, 3, 4, 5]

// array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};

System.out.println(Arrays.toString(strArray));

output: [John, Mary, Bob]

ඔබ jdk 8 ධාවනය කරන්නේ නම්.

public static void print(int[] array) {
    StringJoiner joiner = new StringJoiner(",", "[", "]");
    Arrays.stream(array).forEach(element -> joiner.add(element + ""));
    System.out.println(joiner.toString());
}


int[] array = new int[]{7, 3, 5, 1, 3};
print(array);

ප්‍රතිදානය:

[7,3,5,1,3]

ජාවා 8 හි:

Arrays.stream(myArray).forEach(System.out::println);

Commons.Lang පුස්තකාලය භාවිතා කරන්නේ නම් , අපට කළ හැක්කේ:

ArrayUtils.toString(array)

int[] intArray = new int[] {1, 2, 3, 4, 5};
String[] strArray = new String[] {"John", "Mary", "Bob"};
ArrayUtils.toString(intArray);
ArrayUtils.toString(strArray);

ප්‍රතිදානය:

{1,2,3,4,5}
{John,Mary,Bob}

// ඔබ ජාවා හි කොන්සෝලය මත අරාව මූලද්‍රව්‍යයේ ලිපිනය මුද්‍රණය කරන්නේ නම්.

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");

අරාව මූලද්‍රව්‍ය මුද්‍රණය කිරීමට ක්‍රම කිහිපයක් තිබේ. සියල්ලටම වඩා, මම එය පැහැදිලි කරන්නේ, අරාව යනු කුමක්ද? .. අරාව යනු දත්ත ගබඩා කිරීම සඳහා සරල දත්ත ව්‍යුහයකි..ඔබ අරාව නිර්වචනය කරන විට, සහායක මතක කොටස් වෙන් කරන්න. RAM හි. මෙම මතක කොටස් එක් ඒකකයක් ගනී ..

හරි, මම මේ වගේ පෙළක් සාදන්නම්,

class demo{
      public static void main(String a[]){

           int[] number={1,2,3,4,5};

           System.out.print(number);
      }
}

දැන් ප්‍රතිදානය දෙස බලන්න,

නොදන්නා නූලක් මුද්‍රණය කර ඇති ආකාරය ඔබට දැක ගත හැකිය..මම කලින් සඳහන් කළ පරිදි, අරාව (සංඛ්‍යා අරාව) ප්‍රකාශයට පත් කළ මතක ලිපිනය මුද්‍රණය කර ඇත. ඔබට අරාවෙහි මූලද්‍රව්‍ය පෙන්වීමට අවශ්‍ය නම්, ඔබට "ලූප් සඳහා" භාවිතා කළ හැකිය ..

class demo{
      public static void main(String a[]){

           int[] number={1,2,3,4,5};

           int i;

           for(i=0;i<number.length;i++){
                 System.out.print(number[i]+"  ");
           }
      }
}

දැන් ප්‍රතිදානය දෙස බලන්න,

හරි, එක් මානයක අරාවෙහි මූලද්‍රව්‍යයන් සාර්ථකව මුද්‍රණය කර ඇත..දැන් මම මාන මාන දෙකක් සලකා බලමි..මම මානයන් දෙකක අරාව “අංක 2” ලෙස ප්‍රකාශයට පත් කර “Arrays.deepToString ()” යතුර භාවිතයෙන් මූලද්‍රව්‍ය මුද්‍රණය කරන්නෙමි.එය භාවිතා කිරීමට පෙර ඔබට 'java.util.Arrays' පුස්තකාලය ආනයනය කිරීමට සිදුවේ.

 import java.util.Arrays;

 class demo{
      public static void main(String a[]){

           int[][] number2={{1,2},{3,4},{5,6}};`

           System.out.print(Arrays.deepToString(number2));
      }
}

ප්‍රතිදානය සලකා බලන්න,

ඒ සමගම, ලූප දෙකක් භාවිතා කිරීමෙන් 2D මූලද්‍රව්‍ය මුද්‍රණය කළ හැකිය .. ඔබට ස්තූතියි!