Возможно ли распечатать определенные значения переменных экземпляра объектов, помещенных в список массивов? Геттеры? [Дубликат]

Используя функции java 8.

import java.util.Arrays;
import java.util.List;

/**
 * @author AJMAL SHA
 *
 */
public class ForEach {

    public static void main(String[] args) {

        List<String> features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
        (features).forEach(System.out::println);

    }

}

public static void main(String[] args) {
        answer(10,60);

    }
    public static void answer(int m,int k){
        AtomicInteger n = new AtomicInteger(m);
        Stream<Integer> stream = Stream.generate(() -> n.incrementAndGet()).limit(k);
        System.out.println(Arrays.toString(stream.toArray()));
    }

Подход к потокам Java 8 ...

list.stream().forEach(System.out::println);

Так как Java 8, List наследует метод «forEach» по умолчанию, который вы можете комбинировать с ссылкой метода «System.out :: println» следующим образом:

list.forEach(System.out::println);

    list.stream().map(x -> x.getName()).forEach(System.out::println);

Для списка массива String

list.forEach(s -> System.out.println(Arrays.toString((String[]) s )));

Рассмотрим List<String> stringList, который может быть напечатан многими способами с использованием конструкций Java 8:

stringList.forEach(System.out::println);                            // 1) Iterable.forEach
stringList.stream().forEach(System.out::println);                   // 2) Stream.forEach (order maintained generally but doc does not guarantee)
stringList.stream().forEachOrdered(System.out::println);            // 3) Stream.forEachOrdered (order maintained always)
stringList.parallelStream().forEach(System.out::println);           // 4) Parallel version of Stream.forEach (order not maintained)
stringList.parallelStream().forEachOrdered(System.out::println);    // 5) Parallel version ofStream.forEachOrdered (order maintained always)

Как эти подходы отличаются друг от друга?

Первый подход (Iterable.forEach). Итератор коллекции обычно используется и предназначен для fail-fast , что означает, что он выкинет ConcurrentModificationException, если базовая коллекция будет структурно изменена во время итерации. Как упоминалось в doc для ArrayList:

Структурная модификация - это любая операция, которая добавляет или удаляет один или несколько элементов или явно изменяет размер массива поддержки;

Таким образом, это означает, что для параметра ArrayList.forEach значение допустимо без каких-либо проблем. И в случае одновременного сбора, например. ConcurrentLinkedQueue итератор будет слабо согласованным , что означает, что действия, переданные в forEach, допускают внесение даже структурных изменений без исключения ConcurrentModificationException. Но здесь модификации могут быть или не быть видимыми в этой итерации.

Второй подход (Stream.forEach) - порядок не определен. Хотя это может не произойти для последовательных потоков, но спецификация не гарантирует этого. Кроме того, действие должно быть неинтерферирующим в природе. Как упоминалось в doc :

Поведение этой операции явно недетерминировано. Для параллельных поточных конвейеров эта операция не гарантирует уважения порядка столкновений потока, так как это принесет жертву преимущества параллелизма.

Третий подход (Stream.forEachOrdered) - действие будет выполняться в порядке обнаружения потока. Поэтому всякий раз, когда порядок имеет значение forEachOrdered, без второй мысли. Как упоминалось в doc :

Выполняет действие для каждого элемента этого потока в порядке выполнения потока, если поток имеет определенный порядок встреч.

Во время повторения по синхронизированной коллекции первый подход будет принимать блокировку коллекции один раз и будет удерживать ее во всех методах вызовов к действию, но в случае потоков они используют разделитель коллекции, который не блокировать и полагаться на уже установленные правила невмешательства. В случае, если сбор, поддерживающий поток, изменяется во время итерации, будет выведена ConcurrentModificationException или может возникнуть непоследовательный результат.

Четвертый подход (Параллельный Stream.forEach). Как уже упоминалось, нет гарантии уважать порядок встреч, как ожидалось, в случае параллельных потоков. Возможно, что действие выполняется в разных потоках для разных элементов, которые никогда не могут иметь место с forEachOrdered.

Пятый подход (Параллельный Stream.forEachOrdered) - forEachOrdered будет обрабатывать элементы в порядок, заданный источником, независимо от того, является ли поток последовательным или параллельным. Поэтому нет смысла использовать это с параллельными потоками.

System.out.println(list);//toString() is easy and good enough for debugging.

toString() из AbstractCollection будет достаточно простым и легким для этого. AbstractList является подклассом AbstractCollection, поэтому нет необходимости в цикле и нет toArray ().

Возвращает строковое представление этой коллекции. Строковое представление состоит из списка элементов коллекции в том порядке, в котором они возвращаются его итератором, заключенным в квадратные скобки («[]»). Смежные элементы разделяются символами «,» (запятая и пробел). Элементы преобразуются в строки, как и String.valueOf (Object).

Если вы используете какой-либо пользовательский объект в своем списке, скажем, Student, вам нужно переопределить его метод toString() (он всегда полезно переопределить этот метод), чтобы иметь значимый результат

См. приведенный ниже пример:

public class TestPrintElements {

    public static void main(String[] args) {

        //Element is String, Integer,or other primitive type
        List<String> sList = new ArrayList<String>();
        sList.add("string1");
        sList.add("string2");
        System.out.println(sList);

        //Element is custom type
        Student st1=new Student(15,"Tom");
        Student st2=new Student(16,"Kate");
        List<Student> stList=new ArrayList<Student>();
        stList.add(st1);
        stList.add(st2);
        System.out.println(stList);
   }
}


public  class Student{
    private int age;
    private String name;

    public Student(int age, String name){
        this.age=age;
        this.name=name;
    }

    @Override
    public String toString(){
        return "student "+name+", age:" +age;
    }
}

вывод:

[string1, string2]
[student Tom age:15, student Kate age:16]

System.out.println(list); работает для меня.

Вот полный пример:

import java.util.List;    
import java.util.ArrayList;

public class HelloWorld {
     public static void main(String[] args) {
        final List<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");
        System.out.println(list);
     }
}

Он напечатает [Hello, World].

Объекты в списке должны иметь toString, чтобы они могли напечатать что-то значимое для экрана.

Вот быстрый тест, чтобы увидеть различия:

public class Test {

    public class T1 {
        public Integer x;
    }

    public class T2 {
        public Integer x;

        @Override
        public String toString() {
            return x.toString();
        }
    }

    public void run() {
        T1 t1 = new T1();
        t1.x = 5;
        System.out.println(t1);

        T2 t2 = new T2();
        t2.x = 5;
        System.out.println(t2);

    }

    public static void main(String[] args) {        
        new Test().run();
    }
}

И когда это выполняется, результаты, напечатанные на экране, следующие:

t1 = Test$T1@19821f
t2 = 5

Поскольку T1 не переопределяет метод toString, его экземпляр t1 выводится как нечто, что не очень полезно. С другой стороны, T2 переопределяет toString, поэтому мы контролируем, что он печатает, когда он используется в I / O, и мы видим что-то немного лучше на экране.

1. Вы не указали, какие элементы содержатся в списке, если это примитивный тип данных , тогда вы можете распечатать элементы.
2. Но если элементы являются объектами, тогда как Кшитидж Мехта упомянул, что вам нужно реализовать (переопределить) метод «toString» внутри этого объекта - если он еще не реализован - и пусть он возвращает что-то, что означает полное изнутри объекта, например:

   class Person {
       private String firstName;
       private String lastName;
   
       @Override
       public String toString() {
           return this.firstName + " " + this.lastName;
       }
   }
   

Я написал функцию дампа, которая в основном печатает публичные элементы объекта, если она не переопределила toString (). Его можно было легко расширить, чтобы вызвать геттеры. Javadoc:

Сбрасывает данный объект в System.out, используя следующие правила:

Если объект Iterable, все его компоненты сбрасываются.

Если Объект или один из его суперклассов переопределяет toString (), «toString» сбрасывается

. Else метод вызывается рекурсивно для всех открытых элементов Object

/**
 * Dumps an given Object to System.out, using the following rules:<br>
 * <ul>
 * <li> If the Object is {@link Iterable}, all of its components are dumped.</li>
 * <li> If the Object or one of its superclasses overrides {@link #toString()}, the "toString" is dumped</li>
 * <li> Else the method is called recursively for all public members of the Object </li>
 * </ul>
 * @param input
 * @throws Exception
 */
public static void dump(Object input) throws Exception{
    dump(input, 0);
}

private static void dump(Object input, int depth) throws Exception{
    if(input==null){
        System.out.print("null\n"+indent(depth));
        return;
    }

    Class<? extends Object> clazz = input.getClass();
    System.out.print(clazz.getSimpleName()+" ");
    if(input instanceof Iterable<?>){
        for(Object o: ((Iterable<?>)input)){
            System.out.print("\n"+indent(depth+1));
            dump(o, depth+1);
        }
    }else if(clazz.getMethod("toString").getDeclaringClass().equals(Object.class)){
        Field[] fields = clazz.getFields();
        if(fields.length == 0){
            System.out.print(input+"\n"+indent(depth));
        }
        System.out.print("\n"+indent(depth+1));
        for(Field field: fields){
            Object o = field.get(input);
            String s = "|- "+field.getName()+": ";
            System.out.print(s);
            dump(o, depth+1);
        }
    }else{

        System.out.print(input+"\n"+indent(depth));
    }
}

private static String indent(int depth) {
    StringBuilder sb = new StringBuilder();
    for(int i=0; i<depth; i++)
        sb.append("  ");
    return sb.toString();
}

Следующее является компактным и избегает цикла в вашем примере кода (и дает вам хорошие запятые):

System.out.println(Arrays.toString(list.toArray()));

Однако, как указывали другие, если у вас нет разумного toString ( ), реализованные для объектов внутри списка, вы получите указатели объектов (на самом деле, хэш-коды), которые вы наблюдаете. Это верно, находятся ли они в списке или нет.

попытайтесь переопределить метод toString (), поскольку вы хотите, чтобы этот элемент был напечатан. поэтому способ печати может быть следующим:

for(int i=0;i<list.size();i++){
    System.out.println(list.get(i).toString());
} 

Или вы можете просто использовать утилиты Apache Commons:

https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/ArrayUtils .html # toString-java.lang.Object -

List<MyObject> myObjects = ...
System.out.println(ArrayUtils.toString(myObjects));

   List<String> textList=  messageList.stream()
                            .map(Message::getText)
                            .collect(Collectors.toList());

        textList.stream().forEach(System.out::println);
        public class Message  {

        String name;
        String text;

        public Message(String name, String text) {
            this.name = name;
            this.text = text;
        }

        public String getName() {
            return name;
        }

      public String getText() {
        return text;
     }
   }

Я сейчас работаю над этим ...

List<Integer> a = Arrays.asList(1, 2, 3);
List<Integer> b = Arrays.asList(3, 4);
List<int[]> pairs = a.stream()
  .flatMap(x -> b.stream().map(y -> new int[]{x, y}))
  .collect(Collectors.toList());

Consumer<int[]> pretty = xs -> System.out.printf("\n(%d,%d)", xs[0], xs[1]);
pairs.forEach(pretty);