Я согласен с ответом от zacherates.
Но вы можете сделать вызов intern () в ваших нелиберальных строках.
Из примера zacherates:
// ... but they are not the same object
new String("test") == "test" ==> false
Если вы ставите нелитеральное равенство строки, это правда
new String("test").intern() == "test" ==> true
Начиная с 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 ]
Использование регулярного цикла for - самый простой способ печати массива, на мой взгляд. Здесь у вас есть пример кода, основанный на вашем intArray
for (int i = 0; i < intArray.length; i++) {
System.out.print(intArray[i] + ", ");
}
. Он дает результат как ваш 1, 2, 3, 4, 5
System.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", ");
– Nepoxx
16 July 2014 в 18:39
System.out.print(i + (i < intArray.length - 1 ? ", " : ""));
для объединения этих двух строк.
– Nick Suwyn
11 January 2016 в 19:55
В 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));
for(int n: someArray) {
System.out.println(n+" ");
}
n
- это фактическое значение из массива, а не индекс. Для регулярного цикла цикла он также будет (someArray.length - 1) == i
, поскольку он прерывается, когда i
равен длине массива.
– Radiodef
6 August 2018 в 22:02
Самый простой способ печати массива - использовать for-loop:
// initialize array
for(int i=0;i<array.length;i++)
{
System.out.print(array[i] + " ");
}
T[] myArray
, равен for (int i = 0; i < myArray.length; i++) { System.out.println(myArray[i] + " "); }
– Nic Hartley
17 January 2016 в 01:27
Недавно я столкнулся с этим сообщением в Vanilla #Java . Это не очень удобно писать Arrays.toString(arr);
, а затем импортировать java.util.Arrays;
все время.
Обратите внимание, что это не постоянное исправление любыми способами. Просто взломать, что упростит отладку.
Печать массива напрямую дает внутреннее представление и hashCode. Теперь все классы имеют 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
для таких событий.
Object
? Можем ли мы продолжить эту идею? Не то, что я думаю, что изменение поведения по умолчанию объектов java.lang. * - это то, что я бы рекомендовал ...
– YoYo
11 September 2017 в 15:52
Вы можете прокручивать массив, распечатывая каждый элемент, когда вы выполняете цикл. Например:
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
Он всегда должен работать в зависимости от используемой вами версии 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};
Обновление:
Да! это должно означать, что преобразование массива в массив объектов ИЛИ для использования массива Object является дорогостоящим и может замедлить выполнение. это происходит по характеру java, называемому autoboxing.
Так что только для печати, его не следует использовать. мы можем сделать функцию, которая принимает массив как параметр и печатает желаемый формат как
public void printArray(int [] a){
//write printing code
}
toString(..)
, он побеждает меня, почему кто-то это сделает.
– Debosmit Ray
13 May 2016 в 11:35
Существует несколько способов печати элементов массива. Прежде всего, я объясню, что такое массив? .. Массив - это простая структура данных для хранения данных. Когда вы определяете массив, Allocate set вспомогательные блоки памяти в ОЗУ. Блоки памяти берутся на один блок.
Хорошо, я создам такой массив,
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-элементы. Спасибо!
Использование методов 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>
Чтобы добавить ко всем ответам, печать объекта как строки JSON также является опцией.
Использование Jackson:
ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));
Использование Gson:
Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));
Начиная с Java 8, можно также воспользоваться методом join()
, предоставленным классом String , чтобы распечатывать элементы массива без скобок и разделяться разделителем выбора (который является символом пробела для примера, показанного ниже):
String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting)
Выход будет «Привет, амиго!».
Сначала сначала проверяйте стандартные библиотеки. Попробуйте:
System.out.println(Arrays.toString(array));
или если ваш массив содержит другие массивы в качестве элементов:
System.out.println(Arrays.deepToString(array));
String[] array = {"John", "Mahta", "Sara"}
, и мы хотим получить этот результат без скобок и запятых: John Mahta Sara
?
– Hengameh
29 August 2015 в 02:35
String.join(" ", Arrays.asList(array))
. документ
– Justin
5 March 2016 в 00:14
Вы можете использовать Arrays.toString()
String[] array = { "a", "b", "c" };
System.out.println(Arrays.toString(array));
Упрощенный ярлык, который я пробовал, это:
int x[] = {1,2,3};
String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
System.out.println(printableText);
Он будет печатать
1
2
3
В этом подходе нет циклов, и это лучше всего для небольших массивов
В java 8:
Arrays.stream(myArray).forEach(System.out::println);
Это отмечено как дубликат для печати байта [] . Примечание: для массива байтов существуют дополнительные методы, которые могут быть подходящими.
Вы можете напечатать его как строку, если он содержит символы 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.
Различные способы печати массивов в 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);
Выход: [один, два, три, четыре ]
blockquote>
- Использование
toString()
String[] array = new String[] { "One", "Two", "Three", "Four" }; System.out.println(Arrays.toString(array));
Выход: [Один, Два, Три, Четыре]
blockquote>
- Печать массива массивов
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.
Ресурс: Доступ к массиву [10] [10] ]
Arrays.deepToString(arr)
печатает только одну строку.
int[][] table = new int[2][2];
Чтобы получить таблицу для печати в виде двумерной таблицы, мне пришлось это сделать:
System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));
Кажется, что метод Arrays.deepToString(arr)
должен принимать разделительная строка, но, к сожалению, это не так.
Есть еще один способ, если ваш массив имеет тип char []:
char A[] = {'a', 'b', 'c'};
System.out.println(A); // no other arguments
печатает
abc
Если вы используете Java 1.4, вы можете сделать следующее:
System.out.println(Arrays.asList(array));
(это тоже работает в 1.5+).
Приятно знать, однако, что для «всегда сначала проверяйте стандартные библиотеки», я бы никогда не наткнулся на трюк Arrays.toString( myarray )
- так как я концентрировался на типе myarray, чтобы посмотреть, как это сделать. Я не хотел, чтобы я повторял это: мне нужен простой вызов, чтобы он выглядел так же, как и в отладчике Eclipse, и myarray.toString () просто этого не делал.
import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );
String[] array = {"John", "Mahta", "Sara"}
, и мы хотим получить этот результат без скобок и запятых: John Mahta Sara
?
– Hengameh
29 August 2015 в 02:35
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);
}
}
}
// 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]
Если вы хотите распечатать, оцените контент Array, который вы можете использовать Arrays.toString
jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }
jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"
jshell>
До Java 8 мы могли бы использовать Arrays.toString(array)
для печати одномерного массива и Arrays.deepToString(array)
для многомерных массивов. У нас есть опция Stream
и lambda
в Java 8, которая также может использоваться для печати массива.
Печать одномерного массива:
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] [John, Mary, Bob] 1 2 3 4 5 John Mary Bob
blockquote>Печать многомерного массива На всякий случай, когда мы хотим напечатать многомерный массив, мы можем использовать
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]] [[John, Bravo], [Mary, Lee], [Bob, Johnson]] 11 12 21 22 31 32 33 Джон Браво Мэри Ли Боб Джонсон
blockquote>
String[] array = {"John", "Mahta", "Sara"}
, и мы хотим получить этот результат без скобок и запятых: John Mahta Sara
?
– Hengameh
29 August 2015 в 02:33
В 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
*/
Arrays.stream(strArray).forEach(System.out::println);
– Alexis C.
22 May 2014 в 23:01
System.out::println
, который является ссылкой на метод Java 8. Вы создаете ненужную лямбду.
– Boris the Spider
20 September 2014 в 10:11
Arrays.asList
и сделайте Arrays.stream(strArray).forEach(System.out::println)
– Justin
5 March 2016 в 00:16
Stream.of
будет делать .skip(n).limit(m)
. Текущая реализация не возвращает поток SIZED, тогда как Arrays.stream(T[], int, int)
делает это, что приводит к лучшим результатам разделения, если вы хотите выполнять операции параллельно. Также, если у вас есть int[]
, вы можете случайно использовать Stream.of
, который вернет Stream<int[]>
с одним элементом, а Arrays.stream
даст вам IntStream
напрямую.
– Alexis C.
27 March 2016 в 20:41
В качестве прямого ответа решение, предоставляемое несколькими, включая @Esko , с использованием Arrays.toString
и Arrays.deepToString
, является просто лучшим.
Ниже я пытаюсь перечислить некоторые из других предложенных методов, пытающихся немного улучшить, причем наиболее заметным дополнением является использование оператора 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);
Для каждого цикла также можно использовать для печати элементов массива:
int array[] = {1, 2, 3, 4, 5};
for (int i:array)
System.out.println(i);
Существует следующий способ печати массива
// 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);
}
String[] array = {"John", "Mahta", "Sara"}
, и мы хотим получить этот результат без скобок и запятых:John Mahta Sara
? – Hengameh 29 August 2015 в 02:34Arrays.deepToString()
принимает толькоObject []
(или массив классов, которые расширяютObject
, напримерInteger
, поэтому он не будет работать с примитивным массивом типаint []
. НоArrays.toString(<int array>)
работает отлично подходит для примитивных массивов. – Marcus 12 December 2015 в 00:25System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"}))
напечатаетJohn Mahta Sara
. – dorukayhan 13 March 2017 в 15:15