Какой самый простой способ распечатать массив Java?
Вопрос
В Java массивы не переопределяют toString()
, поэтому, если вы попытаетесь напечатать его напрямую, вы получите имя класса + @ + шестнадцатеричный код 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]
Решение
Начиная с Java 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 ]
Другие советы
Всегда сначала проверяйте стандартные библиотеки.Пытаться:
System.out.println(Arrays.toString(array));
или если ваш массив содержит другие массивы в качестве элементов:
System.out.println(Arrays.deepToString(array));
Приятно это знать, однако, что касается «всегда сначала проверяйте стандартные библиотеки», я бы никогда не наткнулся на трюк Arrays.toString( myarray )
--поскольку я сосредоточился на типе моего массива, чтобы понять, как это сделать.Я не хотел повторять это:Мне нужен был простой вызов, чтобы он выглядел аналогично тому, что я вижу в отладчике Eclipse, а 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
*/
Если вы используете Java 1.4, вместо этого вы можете сделать:
System.out.println(Arrays.asList(array));
(Конечно, это работает и в версии 1.5+.)
Начиная с Java 8, можно также воспользоваться преимуществами join()
метод, предусмотренный Строковый класс чтобы распечатать элементы массива без скобок и разделенные выбранным разделителем (который является символом пробела в примере, показанном ниже):
String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting)
Результатом будет «Привет, амиго!».
Arrays.toString
В качестве прямого ответа решение, предоставленное несколькими, в том числе @Esko, используя Arrays.toString
и Arrays.deepToString
методы, просто лучшие.
Java 8 — Stream.collect(joining()), Stream.forEach
Ниже я попытаюсь перечислить некоторые другие предложенные методы, пытаясь их немного улучшить, причем наиболее заметным дополнением является использование Stream.collect
оператор, используя joining
Collector
, чтобы имитировать то, что String.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);
До Java 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
Джон
Мэри
Боб
Печать многомерного массиваНа всякий случай мы хотим напечатать многомерный массив, мы можем использовать 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+" ");
}
Различные способы печати массивов в Java:
Простой способ
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);
Выход:[Один два три четыре]
С использованием
toString()
String[] array = new String[] { "One", "Two", "Three", "Four" }; System.out.println(Arrays.toString(array));
Выход:[Один два три четыре]
Печать массива массивов
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()
?Без изменений класс Object выглядит следующим образом:
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(..)
начиная с Java 5, toString(..)
можно легко изменить на deepToString(..)
чтобы добавить поддержку массивов, содержащих другие массивы.
Я нашел это весьма полезным хаком, и было бы здорово, если бы Java могла просто добавить это.Я понимаю потенциальные проблемы с очень большими массивами, поскольку строковые представления могут быть проблематичными.Может быть, передать что-то вроде System.out
или 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};
Обновлять :
Да !Следует отметить, что преобразование массива в массив объектов ИЛИ использование массива объекта является дорогостоящим и может замедлить выполнение.это происходит по природе Java, называемой автобоксингом.
Поэтому его не следует использовать только для целей печати.мы можем создать функцию, которая принимает массив в качестве параметра и печатает желаемый формат как
public void printArray(int [] a){
//write printing code
}
В Java 8 это легко.есть два ключевых слова
- транслировать:
Arrays.stream(intArray).forEach
ссылка на метод:
::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[], есть еще один способ:
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 = new Gson();
System.out.println(gson.toJson(anyArray));
Упрощенный ярлык, который я пробовал, таков:
int x[] = {1,2,3};
String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
System.out.println(printableText);
Он будет печатать
1
2
3
В этом подходе не требуются циклы, и он лучше всего подходит только для небольших массивов.
Вы можете перебирать массив, распечатывая каждый элемент по ходу цикла.Например:
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);
}
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>
Цикл for-each также можно использовать для печати элементов массива:
int array[] = {1, 2, 3, 4, 5};
for (int i:array)
System.out.println(i);
Это помечено как дубликат для печать байта[].Примечание:для массива байтов могут подойти дополнительные методы.
Вы можете распечатать его как строку, если она содержит символы 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);
или если вы хотите распечатать его как base64.
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]
В Яве 8:
Arrays.stream(myArray).forEach(System.out::println);
Существует несколько способов распечатать элементы массива. Прежде всего, я объясню, что такое массив?.. Массив — это простая структура данных для хранения данных. Когда вы определяете массив, выделите набор вспомогательных блоков памяти. в оперативной памяти.Эти блоки памяти занимают одну единицу..
Хорошо, я создам такой массив:
class demo{
public static void main(String a[]){
int[] number={1,2,3,4,5};
System.out.print(number);
}
}
Теперь посмотрите на результат,
Вы можете увидеть напечатанную неизвестную строку. Как я уже упоминал ранее, печатается адрес памяти, для которого объявлен массив (числовой массив). Если вы хотите отображать элементы в массиве, вы можете использовать «цикл for», вот так.
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]+" ");
}
}
}
Теперь посмотрите на результат,
Хорошо, элементы одномерного массива успешно напечатаны. Теперь я собираюсь рассмотреть двухмерный массив. Я объявлю двухмерный массив как «number2» и распечатаю элементы, используя ключевое слово «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));
}
}
рассмотрим результат,
В то же время, используя два цикла for, можно распечатать 2D-элементы. Спасибо!
если вы используете 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]
Если вы используете Библиотека 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}
Если вы хотите распечатать, оцените содержимое массива, которое вы можете использовать Arrays.toString
jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }
jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"
jshell>