Adding elements to a List is too slow

python append list to another list
python list append slow
python list extend
append to empty list python
extend the empty list 'emplist2' created above with elements 'a', 'b', 'c'.
how to overwrite a list in python
move items in a list python
append float to list python

I have this loop:

List<Integer> numbers = new ArrayList<Integer>();
 for(int x=0; x<citiesNames.size();x++){
            List<Cities> numeroCiudades = citiesRepository.findByCity(citiesNames.get(x));
            numbers.add(numeroCiudades.size());
            //System.out.println(numeroCiudades.size());
        }

where citiesNames is a List of String which contains 16584 elements and findByCity a method where I pass a String and it search in the database the correponding entries. What I want to do is to search the correponding entries of each city, check the number of entries, and add the number of entries to a Integer List. But this loop is too slow, is taking a very long time to show te result. How can I optimize this?

I don't clearly get why you have to "pack" all cities in a List when you could create a function in citiesRepository that returns an int with the number of entries that particular city has. (That would increase performance a lot. Thus, the program would be able to just return a simple int instead of a whole class instantiation) (Supposing you have access to citiesRepository).

In addition, it could make sense to set assign list capacity in advance. On large list resizing can provoke significant performance drops (read more about how ArrayList works here)

Append vs Extend in Python Lists, Adding Elements to a List. Lists are one of the most useful data structures available in Python, or really any programming language, since they're used in so� That will avoid the cost of resizing the list while adding the strings. List<T>, like all similar collections, tries to minimize the cost of resizing by doubling the capacity when it runs out of space but still, the cost of resizing is not 0, especially when the collection gets large.

You could use a parallel stream, assuming citiesName is a normal Java collections type:

citiesName.parallelStream()
          .map(citiesRepository::findByCity)
          .collect(Collectors.toList())

Just beware the pitfalls of the parallel stream and how it uses the shared ForkJoinPool.

Poor List performance - append() is too slow - Python, I have a pretty basic problem: I've got a list of around 15000 (small) list with a dictionary of dictionaries, so the 24,000 elements are split into� Adding Elements to a List Lists are one of the most useful data structures available in Python, or really any programming language, since they're used in so many different algorithms and solutions. Once we have created a list, often times we may need to add new elements to it, whether it be at the end, beginning, or somewhere in between. Python offers us three different methods to do so. In

To optimize this loop, you will have to modify findByCity so that it could maybe process all of it at once. If you can't modify findByCity, you can always use parallelism with Streams:

    int numbers[] = citiesNames.parallelStream()
            .mapToInt(c -> citiesRepository.findByCity(c).size())
            .toArray();

Slow list append (general update?) performance � Issue #1573 , Given a document with a list of 20000 elements, appending/pushing can improve the speed, or investigation into why this is a slow operation. Questions: I know that it is not allowed to remove elements while iterating a list, but is it allowed to add elements to a python list while iterating. Here is an example: for a in myarr: if somecond(a): myarr.append(newObj()) I have tried this in my code and it seems to works fine, however i dont

List<T>.Insert is very slow? - MSDN, Insert method to insert my elements in the correct position as opposed to just adding them to the end of the list. The collection is about 200000� This enables you to add an array of items to the list in a single operation. However, if you want to add items one at a time using the Add method of the ListView.ListViewItemCollection class, you can use the BeginUpdate method to prevent the control from repainting the ListView every time that an item is added.

Python Performance Tips, Part 1, For example, you can speed up your program by not importing a long You can, however, append an element to the end of the list efficiently� The problem here is that we're still creating too many jQuery objects. Even though we've solved the reflow problem, there is a lot of overhead to create a jQuery object. Of course, for a single object the convenience of jQuery far outweighs the minimal performance hit. But if we're dealing with 10,000 elements the inefficiency is more than

List updates very slowly and block…, List updates very slowly and blocks UI However, when changes aren't that dramatic (adding astue=true which makes count of work orders go from 50 to 5) it � On the other hand, a linked list has constant time for adding to the beginning of the list, whereas in the case of an ArrayList, the elements must be "shuftied" along, an operation that takes some time proportional to the number of elements. But, for a given list size, say, 100 elements, it may still be quicker to "shufty" 100 elements than it

Comments
  • Is the return type of citiesNames.get a String? You may wind up optimizing citiesRepository.findByCity.
  • You're declaring the list inside the loop. That doesn't seem right at all.
  • I guess it is more your database searching that is slowing down things, rather than the adding to the ArrayList.
  • In addition on what has been said, it could make sense to set assign list capacity in advance. On large list resizing (which happens) can provoke significant performance drops. Read on what capacity is and how ArrayList works.
  • In addition to @AnisR. 's comment - try to fetch all the city names in a batch or using pagination if the amount can be significant (100 is significant enough for many usages)
  • This still fetches every city from the database. Streams are good for readability, not performance.
  • Agree. A batch operation would be preferred, but it's not always feasible (i.e. you don't have control over the DAO or remote API to offer a batch operation). A parallel stream is a step above a for loop.