Как получить байты строки? [Дубликат]

Я согласен с ответом от zacherates.

Но вы можете сделать вызов intern () в ваших нелиберальных строках.

Из примера zacherates:

// ... but they are not the same object
new String("test") == "test" ==> false 

Если вы ставите нелитеральное равенство строки, это правда

new String("test").intern() == "test" ==> true 
1536
задан Md. Abu Nafee Ibna Zahid 3 January 2018 в 18:17
поделиться

30 ответов

Начиная с 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 ]
2047
ответ дан 11 revs, 10 users 26% 16 August 2018 в 14:27
поделиться
  • 1
    Это также работает для многомерных массивов. – Alok Mishra 27 May 2015 в 12:47
  • 2
    Что делать, если у нас есть массив строк и требуется простой вывод; например: String[] array = {"John", "Mahta", "Sara"}, и мы хотим получить этот результат без скобок и запятых: John Mahta Sara? – Hengameh 29 August 2015 в 02:34
  • 3
    @Hengameh: Есть несколько других способов сделать это, но моим фаворитом является этот: javahotchocolate.com/notes/java.html#arrays-tostring . – Russ Bateman 29 August 2015 в 06:16
  • 4
    FYI, Arrays.deepToString() принимает только Object [] (или массив классов, которые расширяют Object, например Integer, поэтому он не будет работать с примитивным массивом типа int []. Но Arrays.toString(<int array>) работает отлично подходит для примитивных массивов. – Marcus 12 December 2015 в 00:25
  • 5
    @Hengameh Есть метод, посвященный этому. System.out.println(String.join(" ", new String[]{"John", "Mahta", "Sara"})) напечатает John Mahta Sara. – dorukayhan 13 March 2017 в 15:15

Использование регулярного цикла for - самый простой способ печати массива, на мой взгляд. Здесь у вас есть пример кода, основанный на вашем intArray

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

. Он дает результат как ваш 1, 2, 3, 4, 5

12
ответ дан Andrew_Dublin 16 August 2018 в 14:27
поделиться
  • 1
    Он печатает "1, 2, 3, 4, 5," как вывод, он также печатает запятую после последнего элемента. – icza 10 March 2014 в 13:32
  • 2
    Каково решение не иметь запятую после последнего элемента? – Mona Jalal 16 June 2014 в 02:48
  • 3
    Вы можете заменить код внутри цикла на System.out.print(intArray[i]); if(i != intArray.length - 1) System.out.print(", "); – Nepoxx 16 July 2014 в 18:39
  • 4
    Вы также можете использовать System.out.print(i + (i < intArray.length - 1 ? ", " : "")); для объединения этих двух строк. – Nick Suwyn 11 January 2016 в 19:55
  • 5
    Вы можете использовать StringBuilder и обрезать конечную запятую. int [] intArray = new int [] {1, 2, 3, 4, 5}; final StringBuilder sb = new StringBuilder (); for (int i: intArray) {sb.append (intArray [i]). append (& quot ;, "); } if (sb.length () & gt; 0) {sb.setLength (sb.length () - 1); } System.out.println (sb.toString ()); Эти выходы «1, 2, 3, 4, 5». – Rick Ryker 28 December 2016 в 00:00

В java 8 это легко. есть два ключевых слова

  1. stream: 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));
7
ответ дан Andrii Abramov 16 August 2018 в 14:27
поделиться
  • 1
    Это будет печатать каждый элемент массива на отдельной строке, чтобы он не соответствовал требованиям. – Alex Spurling 29 June 2016 в 15:51
  • 2
    если вы хотите напечатать все элементы в массиве в той же строке, просто используйте print вместо println i.e. int [] intArray = new int [] {1, 2, 3, 4, 5}; Arrays.stream (INTArray) .forEach (System.out :: печать); antwayway without methodreference просто используйте int [] intArray = new int [] {1, 2, 3, 4, 5}; System.out.println (Arrays.toString (INTArray)); – suatCoskun 29 June 2016 в 20:56
for(int n: someArray) {
    System.out.println(n+" ");
}
17
ответ дан Ashish Aggarwal 16 August 2018 в 14:27
поделиться
  • 1
    Таким образом, вы получаете пустое пространство;) – Matthias 21 September 2014 в 10:23
  • 2
    @ matthias .. эта строка не будет заканчиваться пустым пространством System.out.println (n + (некоторый Array.length == n)? & quot; & quot; & quot; & quot; & quot;); – Muhammad Suleman 1 June 2015 в 12:29
  • 3
    Худший способ сделать это. – NameNotFoundException 8 July 2015 в 12:56
  • 4
    Это настолько неэффективно, но полезно для начинающих. – Raymo111 8 April 2018 в 23:23
  • 5
    @MuhammadSuleman Это не работает, потому что это цикл для каждого. 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] + " ");
}
27
ответ дан Community 16 August 2018 в 14:27
поделиться
  • 1
    Правильный цикл, предполагающий 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 для таких событий.

8
ответ дан Debosmit Ray 16 August 2018 в 14:27
поделиться
  • 1
    вы хотите выполнить эти условия if для каждого объекта? – sidgate 10 August 2016 в 11:48
  • 2
    +1 только для идеи, но на основе предыдущего комментария, можем ли мы модифицировать реализации массива напрямую, а не в зависимости от общего родителя 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
4
ответ дан Dylan Black 16 August 2018 в 14:27
поделиться

Он всегда должен работать в зависимости от используемой вами версии 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
} 
7
ответ дан Girish Kumar 16 August 2018 в 14:27
поделиться
  • 1
    Преобразование массива в список просто для печати не похоже на очень изобретательное решение; и учитывая, что у того же класса есть 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-элементы. Спасибо!

0
ответ дан GT_hash 16 August 2018 в 14:27
поделиться
  • 1
    int array [] = {1, 2, 3, 4, 5}; for (int i: array) System.out.println (i); – teran teshara 4 August 2018 в 16:22
  • 2
    попробуйте это, я думаю, что это самый короткий способ печати массива – teran teshara 4 August 2018 в 16:23

Использование методов 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>
3
ответ дан Haim Raman 16 August 2018 в 14:27
поделиться

Чтобы добавить ко всем ответам, печать объекта как строки 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));
4
ответ дан Jean Logeart 16 August 2018 в 14:27
поделиться

Начиная с Java 8, можно также воспользоваться методом join(), предоставленным классом String , чтобы распечатывать элементы массива без скобок и разделяться разделителем выбора (который является символом пробела для примера, показанного ниже):

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

Выход будет «Привет, амиго!».

35
ответ дан laylaylom 16 August 2018 в 14:27
поделиться

Сначала сначала проверяйте стандартные библиотеки. Попробуйте:

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

или если ваш массив содержит другие массивы в качестве элементов:

System.out.println(Arrays.deepToString(array));
306
ответ дан Limbic System 16 August 2018 в 14:27
поделиться
  • 1
    Что делать, если у нас есть массив строк и требуется простой вывод; например: String[] array = {"John", "Mahta", "Sara"}, и мы хотим получить этот результат без скобок и запятых: John Mahta Sara? – Hengameh 29 August 2015 в 02:35
  • 2
    @Hengameh Просто сохраните Arrays.toString (массив) в строковой переменной, а затем удалите фигурные скобки, заменив метод Java – Naveed Ahmad 21 October 2015 в 22:09
  • 3
    @Hengameh В настоящее время с Java 8: String.join(" ", Arrays.asList(array)). документ – Justin 5 March 2016 в 00:14

Вы можете использовать Arrays.toString()

String[] array = { "a", "b", "c" };  
System.out.println(Arrays.toString(array));
3
ответ дан Ma_124 16 August 2018 в 14:27
поделиться
  • 1
    @firephil System.out.println (a [i]); используется с обычным для цикла, где индекс "i" и создается значение для каждого индекса. Я использовал & quot; для каждого & quot; петля. Попробуйте, надеюсь, вы получите мою мысль. – hasham.98 25 December 2016 в 22:22
  • 2
    Да, это самый короткий способ печати массива – teran teshara 4 August 2018 в 16:20

Упрощенный ярлык, который я пробовал, это:

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

Он будет печатать

1
2
3

В этом подходе нет циклов, и это лучше всего для небольших массивов

4
ответ дан Mohamed Idris 16 August 2018 в 14:27
поделиться

В java 8:

Arrays.stream(myArray).forEach(System.out::println);
3
ответ дан Muskovets 16 August 2018 в 14:27
поделиться

Это отмечено как дубликат для печати байта [] . Примечание: для массива байтов существуют дополнительные методы, которые могут быть подходящими.

Вы можете напечатать его как строку, если он содержит символы 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.
1
ответ дан Peter Lawrey 16 August 2018 в 14:27
поделиться

Различные способы печати массивов в Java:

  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);
    

Выход: [один, два, три, четыре ]

  1. Использование toString()
    String[] array = new String[] { "One", "Two", "Three", "Four" };
    System.out.println(Arrays.toString(array));
    

Выход: [Один, Два, Три, Четыре]

  1. Печать массива массивов
    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] ]

17
ответ дан Qwertiy 16 August 2018 в 14:27
поделиться

Arrays.deepToString(arr) печатает только одну строку.

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

Чтобы получить таблицу для печати в виде двумерной таблицы, мне пришлось это сделать:

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

Кажется, что метод Arrays.deepToString(arr) должен принимать разделительная строка, но, к сожалению, это не так.

27
ответ дан Rhyous 16 August 2018 в 14:27
поделиться
  • 1
    Возможно, используйте System.getProperty (& quot; line.separator & quot;); вместо\r\n, поэтому он подходит и для не-Windows. – Scooter 22 December 2013 в 00:01
  • 2
    вы можете использовать System.lineSeparator () сейчас – Novaterata 7 April 2017 в 17:20

Есть еще один способ, если ваш массив имеет тип char []:

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

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

печатает

abc
5
ответ дан Roam 16 August 2018 в 14:27
поделиться

Если вы используете Java 1.4, вы можете сделать следующее:

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

(это тоже работает в 1.5+).

37
ответ дан Ross 16 August 2018 в 14:27
поделиться
  • 1
    К сожалению, это работает только с массивами объектов, а не с массивами примитивов. – Alex Spurling 3 January 2009 в 22:57

Приятно знать, однако, что для «всегда сначала проверяйте стандартные библиотеки», я бы никогда не наткнулся на трюк Arrays.toString( myarray )

- так как я концентрировался на типе myarray, чтобы посмотреть, как это сделать. Я не хотел, чтобы я повторял это: мне нужен простой вызов, чтобы он выглядел так же, как и в отладчике Eclipse, и myarray.toString () просто этого не делал.

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );
85
ответ дан Russ Bateman 16 August 2018 в 14:27
поделиться
  • 1
    Что делать, если у нас есть массив строк и требуется простой вывод; например: String[] array = {"John", "Mahta", "Sara"}, и мы хотим получить этот результат без скобок и запятых: John Mahta Sara? – Hengameh 29 August 2015 в 02:35
  • 2
    @Hengameh Я думаю, что это еще одна тема. Вы можете манипулировать этой строкой с помощью общих операций с строками после этого ... Как Arrays.toString (myarray) .replace (& quot; [& quot ;, & quot; (& quot;) и т. Д. – OddDev 14 January 2016 в 11:42
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);
        }
      }
    }
3
ответ дан SamTebbs33 16 August 2018 в 14:27
поделиться
// 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]
1
ответ дан Stephen Rauch 16 August 2018 в 14:27
поделиться

Если вы хотите распечатать, оцените контент Array, который вы можете использовать Arrays.toString

jshell> String[] names = {"ram","shyam"};
names ==> String[2] { "ram", "shyam" }

jshell> Arrays.toString(names);
$2 ==> "[ram, shyam]"

jshell> 
-1
ответ дан Sudip Bhandari 16 August 2018 в 14:27
поделиться

До 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

Печать многомерного массива На всякий случай, когда мы хотим напечатать многомерный массив, мы можем использовать 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 Джон Браво Мэри Ли Боб Джонсон

23
ответ дан Tom 16 August 2018 в 14:27
поделиться
  • 1
    Что делать, если у нас есть массив строк и требуется простой вывод; например: 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
*/
70
ответ дан Yassin Hajaj 16 August 2018 в 14:27
поделиться
  • 1
    Или менее громоздким, Arrays.stream(strArray).forEach(System.out::println); – Alexis C. 22 May 2014 в 23:01
  • 2
    Это неуклюже. Он должен быть System.out::println, который является ссылкой на метод Java 8. Вы создаете ненужную лямбду. – Boris the Spider 20 September 2014 в 10:11
  • 3
    Просто пропустите Arrays.asList и сделайте Arrays.stream(strArray).forEach(System.out::println) – Justin 5 March 2016 в 00:16
  • 4
    @AlexisC. Потому что он также может использоваться с другими объектами, кроме массивов. – Yassin Hajaj 27 March 2016 в 20:27
  • 5
    @YassinHajaj Оба. Например, если вы хотите иметь поток диапазона над массивом, идиоматическим способом с помощью 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

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);
27
ответ дан Community 17 August 2018 в 08:27
поделиться

Для каждого цикла также можно использовать для печати элементов массива:

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);
3
ответ дан Ma_124 17 August 2018 в 08:27
поделиться
  • 1
    @firephil System.out.println (a [i]); используется с обычным для цикла, где индекс "i" и создается значение для каждого индекса. Я использовал & quot; для каждого & quot; петля. Попробуйте, надеюсь, вы получите мою мысль. – hasham.98 25 December 2016 в 22:22
  • 2
    Да, это самый короткий способ печати массива – teran teshara 4 August 2018 в 16:20

Существует следующий способ печати массива

 // 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);
     }
3
ответ дан Muskovets 17 August 2018 в 08:27
поделиться