Those are arrays of primitives (`[B == byte[]`, `[C == char`, `[I == int`). `[Lx;` is an array of class type `x`.

For a full list:

    [Z = boolean
    [B = byte
    [S = short
    [I = int
    [J = long
    [F = float
    [D = double
    [C = char
    [L = any non-primitives(Object)

Also see the Javadoc for [`Class.getName`][1].


  [1]: https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html#getName--

Looks like an array of characters (C)/bytes (B)/ints (I).

I have a float[] and i would like to get a list with the same elements. I could do the ugly thing of adding them one by one but i wanted to use the Arrays.asList method. There is a problem though. This works:

    List&lt;Integer&gt; list = Arrays.asList(1,2,3,4,5);

But this does not.

    int[] ints = new int[] {1,2,3,4,5};
    List&lt;Integer&gt; list = Arrays.asList(ints);

The asList method accepts a varargs parameter which to the extends of my knowledge is a &quot;shorthand&quot; for an array. 

Questions:  

  - Why does the second piece of code returns a `List&lt;int[]&gt;` but not `List&lt;int&gt;`.

  - Is there a way to correct it?

  - Why doesn&#39;t autoboxing work here; i.e. `int[]` to `Integer[]`?

Arrays.asList() not working as it should?

The fact that it is a LINQ result might perhaps not be relevant for the question, but I&#39;m mentioning it anyway - since this is the context which has resulted in this question. 

I run a LINQ query. The result is an; 

    IEnumerable&lt;MyClass&gt; 

I want to put the result into an ObservableCollection; 

    ObservableCollection&lt;MyClass&gt; 

How do I do this cast? (without running through the IEnumerable and copying elements to the ObservableCollection). I notice LINQ has got a few To..() functions, but it doesn&#39;t seem to help me for this cast..? 

Cast LINQ result to ObservableCollection

I am trying out a tool jhat here to test my java memory usage. It reads in a heap dump file and prints out information as html. However, the tables shows as follows:

    Class Instance Count Total Size 
    class [B  36585  49323821  
    class [Lcom.sun.mail.imap.IMAPMessage;  790  16254336  
    class [C  124512  12832896  
    class [I  23080  11923504  
    class [Ljava.lang.Object;  13614  6664528  
    class java.lang.String  108982  2179640  
    class java.lang.Integer  219502  878008  


What are those [B [C etc classes?

What does the class class [B represents in Java?

I am trying out a tool jhat here to test my java memory usage. It reads in a heap dump file and prints out information as html. However, the tables shows as follows:
<pre><code class="hljs language-vbnet">Class Instance Count Total Size 
class [B 36585 49323821 
class [Lcom.sun.mail.imap.IMAPMessage; 790 16254336 
class [C 124512 12832896 
class [I 23080 11923504 
class [Ljava.lang.Object; 13614 6664528 
class java.lang.String 108982 2179640 
class java.lang.Integer 219502 878008 
</code></pre>
What are those [B [C etc classes?

Are there known difference(s) between String.replaceAll() and Matcher.replaceAll() (On a Matcher Object created from a Regex.Pattern) in terms of performance?

Also, what are the high-level API &#39;ish differences between the both? (Immutability, Handling NULLs, Handling empty strings, etc.)

String replaceAll() vs. Matcher replaceAll() (Performance differences)

What is the difference between the `lazySet` and `set` methods of `AtomicInteger`? The [documentation][1] doesn&#39;t have much to say about `lazySet`:

&gt; Eventually sets to the given value.

It seems that the stored value will not be immediately set to the desired value but will instead be scheduled to be set some time in the future. But, what is the practical use of this method? Any example?


  [1]: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicInteger.html#lazySet-int-

AtomicInteger lazySet vs. set

Are there any frameworks out there which make it even more easy than it is to build Android applications and would you be interested in one?



Android Framework?

I&#39;m trying to read a CSV file into a list of lists (of strings), pass it around for getting some data from a database, build a new list of lists of new data, then pass that list of lists so it can be written to a new CSV file. _I&#39;ve looked all over, and I can&#39;t seem to find an example on how to do it_. 

I&#39;d rather not use simple arrays since the files will vary in size and I won&#39;t know what to use for the dimensions of the arrays. I have no issues dealing with the files. I&#39;m just not sure how to deal with the list of lists.

Most of the examples I&#39;ve found will create multi-dimensional arrays or perform actions inside the loop that&#39;s reading the data from the file. I know I can do that, but I want to write object-oriented code. If you could provide some example code or point me to a reference, that would be great.

Working with a List of Lists in Java

When writing a Java program, do I have influence on how the CPU will utilize its cache to store my data? For example, if I have an array that is accessed a lot, does it help if it&#39;s small enough to fit in one cache line (typically 128 byte on a 64-bit machine)? What if I keep a much used object within that limit, can I expect the memory used by it&#39;s members to be close together and staying in cache?

Background: I&#39;m building a compressed [digital tree][1], that&#39;s heavily inspired by the [Judy arrays][2], which are in C. While I&#39;m mostly after its node compression techniques, Judy has CPU cache optimization as a central design goal and the node types as well as the heuristics for switching between them are heavily influenced by that. I was wondering if I have any chance of getting those benefits, too?

**Edit**: *The general advice of the answers so far is, don&#39;t try to microoptimize machine-level details when you&#39;re so far away from the machine as you&#39;re in Java. I totally agree, so felt I had to add some (hopefully) clarifying comments, to better explain why I think the question still makes sense. These are below:*

There are some things that are just generally easier for computers to handle because of the way they are built. I have seen Java code run noticeably faster on compressed data (from memory), even though the decompression had to use additional CPU cycles. If the data were stored on disk, it&#39;s obvious why that is so, but of course in RAM it&#39;s the same principle. 

Now, computer science has lots to say about what those things are, for example, locality of reference is great in C and I guess it&#39;s still great in Java, maybe even more so, if it helps the optimizing runtime to do more clever things. But how you accomplish it might be very different. In C, I might write code that manages larger chunks of memory itself and uses adjacent pointers for related data.

In Java, I can&#39;t (and don&#39;t want to) know much about how memory is going to be managed by a particular runtime. So I have to take optimizations to a higher level of abstraction, too. My question is basically, how do I do that? For locality of reference, what does &quot;close together&quot; mean at the level of abstraction I&#39;m working on in Java? Same object? Same type? Same array?

In general, I don&#39;t think that abstraction layers change the &quot;laws of physics&quot;, metaphorically speaking. Doubling your array in size every time you run out of space is a good strategy in Java, too, even though you don&#39;t call `malloc()` anymore.

[1]: http://en.wikipedia.org/wiki/Digital_tree
[2]: http://en.wikipedia.org/wiki/Judy_array

What can I do in Java code to optimize for CPU caching?

---
##UPDATE Feb 10 2012:  
zOompf has completed some very thorough research on this very topic [here](http://zoompf.com/blog/2012/02/lose-the-wait-http-compression). It trumps any findings below.
&lt;br/&gt;

---
##UPDATE Sept 11 2010:  
##A testing platform has been created for this [here](http://www.vervestudios.co/projects/compression-tests/)
&lt;br/&gt;

---

&lt;br/&gt;
HTTP 1.1 definitions of GZIP and DEFLATE (zlib) for some background information:

&quot; &#39;Gzip&#39; is the gzip format, and __&#39;deflate&#39; is the zlib format__. They
should probably have called the second one &#39;zlib&#39; instead to avoid
confusion with the raw deflate compressed data format. While the HTTP
1.1 RFC 2616 correctly points to the zlib specification in RFC 1950
for the &#39;deflate&#39; transfer encoding, __there have been reports of
servers and browsers that incorrectly produce or expect raw deflate
data per the deflate specification in RFC 1951, _most notably
Microsoft products___. So even though the &#39;deflate&#39; transfer encoding using the
zlib format would be the more efficient approach (_and in fact exactly
__what the zlib format was designed for___), using the &#39;gzip&#39; transfer
encoding is probably more reliable due to an unfortunate choice of
name on the part of the HTTP 1.1 authors.&quot; (source: &lt;http://www.gzip.org/zlib/zlib_faq.html&gt;)

So, my question: if I send RAW deflate data with NO zlib wrapper (or gzip,
for that matter) are there any modern browsers (e.g., IE6 and up, FF,
Chrome, Safari, etc) that can NOT understand the raw deflate
compressed data (assuming HTTP request header &quot;Accept-Encoding&quot; contains &quot;deflate&quot;)?

Deflate data will ALWAYS be a few bytes smaller than GZIP.

If all these browsers can successfully decode the data, what
downsides are there to sending RAW deflate instead of zlib?


&lt;br /&gt;&lt;br /&gt;
##UPDATE Sept 11 2010:  
##A testing platform has been created for this [here](http://www.vervestudios.co/projects/compression-tests/)

Deflate compression browser compatibility and advantages over GZIP

I&#39;m looking to find bottlenecks in my Java application in [Eclipse][1]. I&#39;m thinking this might be useful:

http://www.eclipse.org/projects/project_summary.php?projectid=tptp.performance

Any other good plug-ins to use?

**EDIT** OK, it doesn&#39;t necessarily have to be an Eclipse plug-in. But it would be nice. And, I&#39;m most interested in speed.

  [1]: http://en.wikipedia.org/wiki/Eclipse_(software)


Profiling a Java Application in Eclipse? (plug-in)

I am trying to figure out if there is any difference in performance (or advantages) when we use nio `FileChannel` versus normal `FileInputStream/FileOuputStream` to read and write files to filesystem. I observed that on my machine both perform at the same level, also many times the `FileChannel` way is slower. Can I please know more details comparing these two methods. Here is the code I used, the file that I am testing with is around `350MB`. Is it a good option to use NIO based classes for File I/O, if I am not looking at random access or other such advanced features?

    package trialjavaprograms;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    public class JavaNIOTest {
    	public static void main(String[] args) throws Exception {
    		useNormalIO();
    		useFileChannel();
    	}
    
    	private static void useNormalIO() throws Exception {
    		File file = new File(&quot;/home/developer/test.iso&quot;);
    		File oFile = new File(&quot;/home/developer/test2&quot;);
    
    		long time1 = System.currentTimeMillis();
    		InputStream is = new FileInputStream(file);
    		FileOutputStream fos = new FileOutputStream(oFile);
    		byte[] buf = new byte[64 * 1024];
    		int len = 0;
    		while((len = is.read(buf)) != -1) {
    			fos.write(buf, 0, len);
    		}
    		fos.flush();
    		fos.close();
    		is.close();
    		long time2 = System.currentTimeMillis();
    		System.out.println(&quot;Time taken: &quot;+(time2-time1)+&quot; ms&quot;);
    	}
    
    	private static void useFileChannel() throws Exception {
    		File file = new File(&quot;/home/developer/test.iso&quot;);
    		File oFile = new File(&quot;/home/developer/test2&quot;);
    
    		long time1 = System.currentTimeMillis();
    		FileInputStream is = new FileInputStream(file);
    		FileOutputStream fos = new FileOutputStream(oFile);
    		FileChannel f = is.getChannel();
    		FileChannel f2 = fos.getChannel();
    
    		ByteBuffer buf = ByteBuffer.allocateDirect(64 * 1024);
    		long len = 0;
    		while((len = f.read(buf)) != -1) {
    			buf.flip();
    			f2.write(buf);
    			buf.clear();
    		}
    		
    		f2.close();
    		f.close();
    		
    		long time2 = System.currentTimeMillis();
    		System.out.println(&quot;Time taken: &quot;+(time2-time1)+&quot; ms&quot;);
    	}
    }

 


Java NIO FileChannel versus FileOutputstream performance / usefulness

Is Magento usually so terribly slow?

This is my first experience with it and the admin panel simply takes ages to load and save changes. It is a default installation with the test data.

The server where it is hosted serves other non-Magento sites super fast.  What is it about the PHP code that Magento uses that makes it so slow, and what can be done to fix it?

Why is Magento so slow?

I want to limit the maximum memory used by the JVM. Note, this is not just the heap, I want to limit the total memory used by this process.

How to set the maximum memory usage for JVM?

I was going through the document in [Java Memory Management][1] and in that I came across PermSize which I couldn&#39;t understand. The document says that it stores, &quot;JVM stores its metadata&quot;, but I couldn&#39;t exactly get what is meant by metadata. I was googling and somewhere I read it stores a value object (user defined object).

What kind of objects are stored there? An example with an explanation would be great.

  [1]: http://www.oracle.com/technetwork/java/javase/memorymanagement-whitepaper-150215.pdf

What is &#39;PermSize&#39; in Java?

I have this piece of code in c:

   

    int q = 10;
    int s = 5;
    int a[3];

    printf(&quot;Address of a: %d\n&quot;,    (int)a);
    printf(&quot;Address of a[1]: %d\n&quot;, (int)&amp;a[1]);
    printf(&quot;Address of a[2]: %d\n&quot;, (int)&amp;a[2]);
    printf(&quot;Address of q: %d\n&quot;,    (int)&amp;q);
    printf(&quot;Address of s: %d\n&quot;,    (int)&amp;s);


The output is:

    Address of a: 2293584
    Address of a[1]: 2293588
    Address of a[2]: 2293592
    Address of q: 2293612
    Address of s: 2293608

So, I see that from `a` to `a[2]`, memory addresses increases by 4 bytes each. 
But from `q` to `s`, memory addresses decrease by 4 byte.

I wonder 2 things:

1. Does stack grow up or down? (It looks like both to me in this case)
2. What happen between `a[2]` and `q` memory addresses? Why there are a big memory difference there? (20 bytes).

Note: This is not homework question. I am curious on how stack works. Thanks for any help.

    

Does stack grow upward or downward?

I thought the GC would call Dispose eventually if your program did not but that you should call Dispose() in your program just to make the cleanup deterministic.

However, from my little test program, I don&#39;t see Dispose getting called at all....

    public class Test : IDisposable
    {
        static void Main(string[] args)
        {
            Test s = new Test();
            s = null;
            GC.Collect();
            Console.ReadLine();
        }
    
        public Test()
        {
            Console.WriteLine(&quot;Constructor&quot;);
        }
    
        public void Dispose()
        {
            Console.WriteLine(&quot;Dispose&quot;);
        }
    }

// Output is just &quot;Constructor&quot;, I don&#39;t get &quot;Dispose&quot; as I would expect.  What&#39;s up?

**EDIT:** Yes, I know I should call Dispose() - I do follow the standard pattern when using disposable objects.  My question arises because I&#39;m trying to track down a leak in somebody elses code, which is managed C++ (another layer of complexity that would be the good subject of another thread).

Does garbage collector call Dispose()?

In looking at Go and Erlang&#39;s approach to concurrency, I noticed that they both rely on message passing.

This approach obviously alleviates the need for complex locks because there is no shared state.

However, consider the case of many clients wanting parallel read-only access to a single large data structure in memory -- like a suffix array.

My questions:

 - Will using shared state be faster and use less memory than message passing, as locks will mostly be unnecessary because the data is read-only, and only needs to exist in a single location?

 - How would this problem be approached in a message passing context? Would there be a single process with access to the data structure and clients would simply need to sequentially request data from it? Or, if possible, would the data be chunked to create several processes that hold chunks?

 - Given the architecture of modern CPUs &amp; memory, is there much difference between the two solutions -- i.e., can shared memory be read in parallel by multiple cores -- meaning there is no hardware bottleneck that would otherwise make both implementations roughly perform the same?



Content Type	Original Author	Original Content on Stackoverflow
Question	erotsppa	View Question on Stackoverflow
Solution 1 - Java	Aaron Digulla	View Answer on Stackoverflow
Solution 2 - Java	Rob Di Marco	View Answer on Stackoverflow

What does the class class [B represents in Java?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Cast LINQ result to ObservableCollection

Arrays.asList() not working as it should?

Attributions