Question

我正在尝试打印List的所有元素，但它会打印Object的指针而不是值。

这是我的打印代码......

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

有人可以帮助我，为什么它不打印元素的价值。

Answer 1

以下是紧凑的，并避免示例代码中的循环（并给你很好的逗号）：

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

然而，正如其他人所指出的那样，如果你没有为列表中的对象实现合理的toString（）方法，你将获得你正在观察的对象指针（实际上是哈希码）。无论他们是否在列表中，都是如此。

Answer 2

以下是关于打印列表组件的一些示例：

public class ListExample {

    public static void main(String[] args) {
        List<Model> models = new ArrayList<>();

        // TODO: First create your model and add to models ArrayList, to prevent NullPointerException for trying this example

        // Print the name from the list....
        for(Model model : models) {
            System.out.println(model.getName());
        }

        // Or like this...
        for(int i = 0; i < models.size(); i++) {
            System.out.println(models.get(i).getName());
        }
    }
}

class Model {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Answer 3

从Java 8开始，List继承了一个默认的“forEach”方法，您可以将其与方法引用“System.out :: println”结合使用，如下所示：

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

Answer 4

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

toString()的

AbstractCollection将足够干净且容易做到。 AbstractList是AbstractCollection的子类，所以不需要for循环，也不需要toArray（）。

返回此集合的字符串表示形式。字符串表示由一系列集合中的元素组成它们由迭代器返回，用方括号括起来（＆＃34; []＆＃34）。相邻元素由字符＆＃34;，＆＃34;分隔。（逗号和空间）。元素将转换为字符串将String.valueOf（对象）。

如果您在列表中使用任何自定义对象，比如说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]

Answer 5

Java 8 Streams方法......

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

Answer 6

使用String.join() 例如：

System.out.print(String.join("\n", list)));

Answer 7

列表中的对象必须实现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中使用它时打印的内容，并且我们在屏幕上看到一些更好的东西。

Answer 8

考虑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。正如ArrayList ArrayList.forEach中提到的那样：

结构修改是添加或删除一个或多个的任何操作更多元素，或显式调整后备数组的大小;只是设定元素的价值不是结构修改。

所以这意味着ConcurrentLinkedQueue设置允许的值没有任何问题。并且在并发收集的情况下，例如forEach迭代器将是doc，这意味着允许ConcurrentModificationException中传递的操作进行结构更改，而不会抛出Stream.forEach异常。但是这里的修改可能会也可能不会在那次迭代中可见。

第二种方法（Stream.forEachOrdered） - 订单未定义。虽然顺序流可能不会发生，但规范并不能保证。此外，该行动也必须是非干扰性的。如weakly-consistent中所述：

此操作的行为明确是不确定的。对于并行流管道，此操作不保证尊重流的遭遇顺序，因为这样做会牺牲并行的好处。

第三种方法（forEachOrdered） - 该动作将以流的遭遇顺序执行。因此，无论何时订单问题，都可以毫不犹豫地使用ConcurrentModificationException。如doc中所述：

在遭遇中对此流的每个元素执行操作如果流具有已定义的遭遇顺序，则为流的顺序。

在迭代同步集合时，第一种方法会将集合的锁定一次，并将其保存在所有调用操作方法中，但如果是流，则使用集合的分裂器，它不会锁定并依赖已经建立的无干扰规则。如果在迭代期间修改了流，则会抛出Stream.forEach，或者可能会出现不一致的结果。

第四种方法（并行forEachOrdered） - 如前所述，并不保证在并行流的情况下遵守预期的遭遇顺序。对于不同的元素，可能会在不同的线程中执行操作，Stream.forEachOrdered永远不会出现这种情况。

第五种方法（并行forEachOrdered） - import React, { Component } from 'react'; import { withFormik } from 'formik'; import Yup from 'yup'; import FormNaviagtion from './form-navigation'; import { withRouter } from 'react-router-dom'; class StepOne extends Component{ render(){ return( <div className="add-survey"> <div className="survey-step"> <EnhancedFormHistory /> </div> </div> ) } } const MyInnerForm = props => { const { values, touched, errors, dirty, isSubmitting, handleChange, handleBlur, handleSubmit, handleReset, } = props; const handlePrev = () => { } const handleNext = (e) => { e.preventDefault(); props.submitForm(); props.history.push(`/app/add-survey/step-two`); } return ( <div> <div className="form-group"> <label htmlFor="surveyTitle" className="form-label">Survey Name</label> <input id="surveyTitle" placeholder="Eg: Customer Survey" type="text" value={values.surveyTitle} onChange={handleChange} onBlur={handleBlur} className={errors.surveyTitle && touched.surveyTitle ? 'form-control error' : 'form-control'} /> {errors.surveyTitle && touched.surveyTitle && <div className="input-feedback">{errors.surveyTitle}</div> } </div> <div className="form-group"> <label htmlFor="surveyCategory" className="form-label">Survey Category</label> <select id="surveyCategory" placeholder="Eg: Customer Survey" type="text" value={values.surveyCategory} onChange={handleChange} onBlur={handleBlur} className={errors.surveyCategory && touched.surveyCategory ? 'form-control error' : 'form-control'} > <option value="">Choose a category</option> <option value="1">Politics</option> <option value="2">Science and Technology</option> <option value="3">Entertainment</option> <option value="4">Sports</option> </select> {errors.surveyCategory && touched.surveyCategory && <div className="input-feedback">{errors.surveyCategory}</div>} </div> <div className="footer-navigation"> <a href="#" onClick={handlePrev} className="button button-secondary disabled"> <i className="icon-arrow-back"></i> Return Back </a> <a href="#" onClick={handleNext} className="button button-primary"> Proceed Next <i className="icon-arrow-forward"></i> </a> </div> </div> ); }; const EnhancedForm = withFormik({ mapPropsToValues: () => ({ surveyTitle: '', surveyCategory: '' }), validationSchema: Yup.object().shape({ surveyTitle: Yup.string().required('Survey name is required'), surveyCategory: Yup.string().required('Survey category is required') }), handleSubmit: (values, { setSubmitting }) => { setTimeout(() => { alert(JSON.stringify(values, null, 2)); setSubmitting(false); }, 1000); }, })(MyInnerForm); const EnhancedFormHistory = withRouter(EnhancedForm); export default StepOne;将按源指定的顺序处理元素，而不管流是顺序还是并行。因此，将它与并行流一起使用是没有意义的。

Answer 9

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

    }

}

Answer 10

或者您可以简单地使用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));

Answer 11

您尚未指定列表包含哪些元素，如果是primitive data type，则可以打印出元素。
但是如果元素是对象，那么就像Kshitij Mehta所提到的那样，你需要在该对象中实现（覆盖）方法“toString” - 如果它还没有实现 - 并让它从对象，例如：
```
class Person {
    private String firstName;
    private String lastName;

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

Answer 12

我也遇到过类似的问题。我的代码：

List<Integer> leaveDatesList = new ArrayList<>();

.....inserted value in list.......

方法1：在for循环中打印列表

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

方法2：在forEach，for循环中打印列表

for(Integer leave : leaveDatesList){
    System.out.println(leave);
}

方法3：在Java 8中打印列表

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

Answer 13

这取决于List中存储的对象的类型，以及它是否具有toString()方法的实现。 System.out.println(list)应该打印所有标准的Java对象类型（String，Long，Integer等）。如果使用自定义对象类型，则需要使用自定义对象的override toString()方法。

示例：

class Employee {
 private String name;
 private long id;

 @Override
 public String toString() {
   return "name: " + this.name() + 
           ", id: " + this.id();
 }  
}

测试：

class TestPrintList {
   public static void main(String[] args) {
     Employee employee1 =new Employee("test1", 123);
     Employee employee2 =new Employee("test2", 453);
     List<Employee> employees = new ArrayList(2);
     employee.add(employee1);
     employee.add(employee2);
     System.out.println(employees);
   }
}

Answer 14

我编写了一个转储函数，如果它没有覆盖toString（），它基本打印出一个对象的公共成员。人们可以很容易地将其扩展为呼叫吸气剂。的Javadoc：

使用以下规则将给定对象转储到System.out：



如果Object是Iterable，则转储其所有组件。

如果Object或其中一个超类重写toString（），则＆＃34; toString＆＃34;被倾销

否则，对象的所有公共成员递归调用该方法

/**
 * 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();
}

Answer 15

获取String数组列表

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

Answer 16

import static android.Manifest.permission.READ_CONTACTS;

public class MainActivity extends AppCompatActivity
        implements LoaderManager.LoaderCallbacks<Cursor> {

    private static String[] LOADER_PROJECTION_CONTACTS = new String[] {
            ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME,
            ContactsContract.CommonDataKinds.Phone.NUMBER,
            ContactsContract.CommonDataKinds.Phone.TYPE,
            ContactsContract.CommonDataKinds.Phone._ID};

    private static String[] ADAPTER_PROJECTION_CONTACTS = new String[] {
            ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME,
            ContactsContract.CommonDataKinds.Phone.NUMBER,
            ContactsContract.CommonDataKinds.Phone.TYPE};

    SimpleCursorAdapter adapter;
    int CONTACTS_LOADER = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        int perm = ContextCompat.checkSelfPermission(this, READ_CONTACTS);
        if (perm != PackageManager.PERMISSION_GRANTED)
            ActivityCompat.requestPermissions( this, new String[]{READ_CONTACTS}, 1 );
        else {
            adapter = new SimpleCursorAdapter(
                    this,
                    R.layout.contacts_listview_item,
                    null,
                    ADAPTER_PROJECTION_CONTACTS,
                    new int[]{R.id.txt_contact_name, R.id.txt_contact_phone, R.id.txt_contact_type},
                    0);

            ListView listview_contacts = (ListView) findViewById(R.id.list_contacts);
            listview_contacts.setAdapter(adapter);

            getSupportLoaderManager().initLoader(CONTACTS_LOADER, null, this);
        }
    }

    @Override
    public Loader<Cursor> onCreateLoader(int loaderID, Bundle bundle)
    {
        return new CursorLoader(
                this,
                ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
                LOADER_PROJECTION_CONTACTS,
                ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME + " NOT LIKE '#%'",
                null,
                ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME + "," +
                ContactsContract.CommonDataKinds.Phone.TYPE);
    }

    @Override
    public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
        adapter.swapCursor(cursor);
    }

    @Override
    public void onLoaderReset(Loader<Cursor> loader) {
        adapter.swapCursor(null);
    }

}

Answer 17

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]。

Answer 18

我恰好正在为此工作...

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

Answer 19

For循环以打印列表的内容：

List<String> myList = new ArrayList<String>();
myList.add("AA");
myList.add("BB");

for ( String elem : myList ) {
  System.out.println("Element : "+elem);
}

结果：

Element : AA
Element : BB

如果要单行打印（仅供参考）：

String strList = String.join(", ", myList);
System.out.println("Elements : "+strList);

结果：

Elements : AA, BB

Answer 20

尝试覆盖toString（）方法，因为您希望该元素将是printend。所以打印的方法可以是这样的：

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

Answer 21

Java 11 问题的解决方案是：

String separator = ", ";
String toPrint = list.stream().map(o -> String.valueOf(o)).collect(Collectors.joining(separator));

System.out.println(toPrint);

Answer 22

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

Answer 23

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

如何在Java中打印出List的所有元素？

23 个答案:

这些方法如何彼此不同？