memory-efficient

I am not 100% sure of the mechanism in action so I decided to post here for further clarifications. I am doing a project that should handle large amounts of data in Java (it has to be Java). I would like it to be as efficient as possible. By efficient I mean that memory and speed calculations should come in first and readability should come in second. Now I have two ways to store my data: create one array of MyObject 1) MyObject[][] V = new MyObject[m][n] Or create two arrays of int: 2) int[][] V = new int[m][n] 3) int[][] P = new int[m][n] Clearly MyObject contains at least two fields and

The memory cost obviously depends on exactly how large a module is, but I'm only looking for a general answer: Is it generally expensive or cheap to import a module in Python? If I have a few tens of small scripts that potentially stay in memory for the whole duration of the application, how much will that hog the memory? It sounds like you aren't worried about time cost (good; that would be silly, since modules are only imported once) but memory cost. I put it to you: if you need all the functionality in these modules, then how exactly do you plan to avoid having them all in memory? Might as

Goal: Use a script to run through 5 million - 10 million XML files and evaluate their date, if older than 90 days delete the file. The script would be run daily. Problem: Using powershell Get-ChildItem -recurse, causes the script to lock up and fail to delete any files, I assume this is because of the way Get-ChildItem needs to build the whole array before taking any action on any file. Solution ?: After lots of research I found that [System.IO.Directory]::EnumerateFiles will be able to take action on items in the array before the array is completely built so that should make things more

I'm programming a Bomberman in Java following a tutorial (this is my first game). The tutorial suggests the following code for detecting collisions. for (int p=0; p<entities.size(); p++) { for (int s=p+1; s<entities.size(); s++) { Entity me = (Entity) entities.get(p); Entity him = (Entity) entities.get(s); if (me.collidesWith(him)) { me.collidedWith(him); him.collidedWith(me); } } By now, entities is an array list containing the enemies and the player. As I want to also detect the player collides with walls, should I put every single wall or bricks tile in the level into the entities arraylist

I am programming something in C that creates a lot of Pthreads in Linux on a 256Mb system. I usually have +200Mb free. When I run the program with a low amount of threads it works, but once I make it create around 100 threads it gives errors because the system runs out of memory. I did several tests and each threads use almost 2Mb. The stack size of the threads is set to 16Kb. The code I use to create each thread: pthread_attr_t attr; pthread_attr_init(&attr); size_t stacksize; stacksize = (double) 16*1024; int res = pthread_attr_setstacksize (&attr, stacksize); int res2 = pthread_attr

how expensive is 'new'? I mean, should I aim at reusing the same object or if the object is 'out of scope' it's the same as emptying it? example, say a method creates a list: List<Integer> list = new ArrayList<Integer>(); at the end of the method the list is no longer in use - does it mean that there's no memory allocated to it anymore or does it mean that there's a null pointer to it (since it was 'created'). Alternately, I can send a 'list' to the method and empty it at the end of the method with: list.removeAll(list); will that make any difference from memory point of view? Thanks! its an

This may be a duplicate question but I couldnt find what I am searching. If it exists, sorry about duplication. I want to learn that if the following part of codes are same in terms of memory allocation. //first int n = some_number; for(int i = 0; i < n; i++){ for(int j = 0; j < n; j++){ int a = something; } } //second int i, j, a; for(i = 0; i < n; i++){ for(j = 0; j < n; j++){ a = something; } } I wonder, if java allocates the variable a n^2 times and j n times in the first code or both are allocated only once as in the second code. I tried this couple of times in java but the results are