Using System.arraycopy to copy an array into itself.

I was wondering if there are any potential problems with using code similar to below?
System.arraycopy(Global.queueUrgent, 1, Global.queueUrgent, 0, Global.queueUrgent.length-1); I have an array which works as a job queue. Another thread looks at this queue and then acts on it according to the data held in Global.queueUrgent[0]. Once this task has been accomplished, the first job is removed and the rest of the queue is brought forward one (and hence the code sample).
I understand the risks of a race condition which might occur in my application and can prevent it as much as possible but I was wondering if there were any other concerns I should address. It's important that I use an array such as this for my project.
I haven't tried to implement the code as of yet as I would like to hear your thoughts on it first.
Regards,
Robert (1BillionHex).

user13702320 wrote:
"If the src and dest arguments refer to the same array object, then the copying is performed as if the components at positions srcPos through srcPos+length-1 were first copied to a temporary array with length components and then the contents of the temporary array were copied into positions destPos through destPos+length-1 of the destination array. "
Yeah I understand that. I was just wondering if there was anything that I was missing.
It says "as if" it is copied to a temporary array. Does it actually do this? If so and if I use a large array, would this have an impact on memory usage?It doesn't matter if it actually does it using a temporary array. The point is, it is safe to use the same array for src and dest. Note that java.util.ArrayList's 'remove' method uses exactly the code that you are using. I don't know about memory usage effects. If you do this manually, you do need to set Global.queueUrgent[Global.queueUrgent.length-1] to null to ensure that the objects will be able to be garbage-collected properly when it is time (see what ArrayList.remove does). If you don't, then if you had a 5-element array and remove all 5 elements, you will end up with 5 references to what was originally only in queueUrgent[4], and the object won't be eligible for garbage-collection.
I did have the same question as Kayaman--why not use a real queue? There are several built-in classes that you can use, instead of using an array directly. You claimed that "It's important that I use an array such as this for my project.", but you didn't explain why you think you must use an array.

Similar Messages

Question on System.arraycopy method and multidimensional array

I'm trying to copy from single dimensional to multidimensional array using System.arraycopy method. The following is my problem.
1) I need to specify the index of the multidimensional array while copying. Can I do that ? If yes , how???
eg ; int a[] = new int[3];
int b[] = new int[3][2]; I need to copy from a to b
I tired the following and I'm getting an error.
System.arraycopy(a,0,b[][1],0,3);
How Can I achieve the above?? PLease Help --------------

Java doesn't have multidimensional arrays. When you see an int[][] it's an array of arrays of ints. The arrays of ints might have different lengths like this one:int[][] arr =
{{1,2,3,4},
{1,2,3},
{1,2},
{1}
};Do I need to say that arraycopy as you see it would fail in this case?
If you know what kind of arrays you'll have you can simply implement your own arraycopy method (but it will not be as effecient as System.arraycopy) with a simple for-loop.

Copying Multiple Arrays into One Large Array

I'm currently trying to copy multiple character arrays into one larger character array in a method that prints data gathered from a database. Here is my code:
private static void printData(String[] data){
 try {
 int totalLengthOfAllStrings = 0;
 for(int i = 0; i < data.length; i++) {
 data[i] += '\n';
 totalLengthOfAllStrings += data.length();
int runningLength = 0;
char[] printArray = new char[totalLengthOfAllStrings];
for(int j = 0; j < data.length; j++) {
char[] tempArray = data[j].toCharArray();
runningLength += tempArray.length;
System.arraycopy(tempArray, 0, printArray, runningLength - 1, tempArray.length);
DocFlavor df = DocFlavor.CHAR_ARRAY.TEXT_PLAIN;
Doc printDoc = new SimpleDoc(printArray, df, null);
PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet();
aset.add(new Copies(1));
aset.add(MediaSize.NA.LETTER);
aset.add(Sides.DUPLEX);
PrintService[] services = PrintServiceLookup.lookupPrintServices(df, aset);
if (services.length > 0) {
DocPrintJob job = services[0].createPrintJob();
try {
job.print(printDoc, aset);
System.out.println("Print successful!");
catch (PrintException pe) {
catch(Exception e) {
e.printStackTrace();
I keep getting an ArrayIndexOutOfBoundsException and for the life of me I can't figure out why.
Can anyone help with this?
Thanks!
-Matt

I think your problem lies with the second for loop:
for(int j = 0; j < data.length; j++) {
 char[] tempArray = data[j].toCharArray();
 runningLength += tempArray.length;
 System.arraycopy(tempArray, 0, printArray, runningLength - 1, tempArray.length);
}If I am not wrong, you should swap the sequence of the runningLength and System.arraycopy statements, and also move the minus 1 from arraycopy statement to the runningLength statement. The result would look like this:
for(int j = 0; j < data.length; j++) {
 char[] tempArray = data[j].toCharArray();
 System.arraycopy(tempArray, 0, printArray, runningLength, tempArray.length); // swapped and removed the -1
 runningLength += tempArray.length - 1; // swapped and appended the -1
}The main reason for these changes is because when j == data.length - 1, the value of runningLength would have already exceeded the size of printArray. Therefore, swapping the position would be able to overcome this problem.

System.arraycopy (2 dim array) and growth of 2 dim array

Hi everybody
I am working on a program which contains a module that can perform Cartesian product on number of sets.
The code I have developed so far is :
import java.lang.reflect.Array;
public class Cart5 {
public static void main(String[] args) throws Exception
int pubnewlength;
// declare SolArray
int[][] solArray;
// initialize solArray
solArray=new int[1][4];
// Use for method
for (int ii=0 ; ii<4 ; ii++)
solver(solArray,ii);
// Print the array ?
System.out.println("\n The array was changed ... " );
} // End main
public void solver(int Solarray2[][] , int abi)
int[][] A = { {1,2,3,5},
 {4,6,7},
 {11,22,9,10},
 {17,33}
jointwoArrays(solarray2,A,abi);
// some other operations
} // End Solver method
public void jointwoArrays(int solarray3[][] , int aArray[][],int indexA)
int y,u;
int[][] tempArray;
// calculate growth of rows:
pubnewlength=solArray3.length * aArray[indexA].length;
//Fill TempArray
y=solArray3[0].length;
u=solArray3.length;
tempArray=new int[u][y];
// Use system.arraycopy to copy solArray3 into tempArray -- How ?
// Change the size of arrow to proper size -- How ?
solArray3 = (int[][]) arrayGrow(solArray3);
// Join operation - Still under construction
for(int i = 0, k = 0; i < tempArray.length; i++)
 for(int j = 0; j < set3.length; j++)
 for (q=0;q<=2;q++)
 { solArray3[k][q] = tempArray[i][q];}
 solArray3[k][q]= aArray[indexA][j];
 ++k;
} // End jointwoArrays method
// This module is from http://www.java2s.com/ExampleCode/Language-Basics/Growarray.htm
 static Object arrayGrow(Object a) {
 Class cl = a.getClass();
 if (!cl.isArray())
 return null;
 Class componentType = a.getClass().getComponentType();
 int length = Array.getLength(a);
 int newLength = pubnewlength;
 Object newArray = Array.newInstance(componentType, newLength);
 System.arraycopy(a, 0, newArray, 0, length);
 return newArray;
} // End ClassI deeply appreciate your help with these 3 questions :
1. How can I use system.arraycopy to copy my two dimensional array? I have searched but examples seem to be about one dim arrays.
2. How can I change the "static Object arrayGrow(Object a)" , to grow my two dimensional array ?
3. If you know any codes or articles or java code regarding cartesian products , please tell me.
Thank you
Denis

1. How can I use system.arraycopy to copy my two
dimensional array? I have searched but examples seem
to be about one dim arrays.That's because you can't do it in one call. You need to create a loop which copies each 'row".
>
2. How can I change the "static Object
arrayGrow(Object a)" , to grow my two dimensional
array ?Why do you make it so complicated (generic). Make it take an int[][] array instead, and see the answer from above.
>
3. If you know any codes or articles or java code
regarding cartesian products , please tell me.There are probably lots of them if you google.
Kaj

Performance of System.arraycopy and Arrays.fill

I have some code where I call a function about 1,000,000 times. That function has to allocate a small array (around 15 elements). It would be much cheaper if the client could just allocate the array one single time outside of the function.
Unfortunately, the function requires the array to have all of its elements set to null. With C++, I would be able to memset the contents of the array to null. In Java, the only methods I have available to me are System.arraycopy() and Arrays.fill().
Apparently, Arrays.fill() is just a brain-dead loop. It costs more for Arrays.fill() to set the elements to null than it does to allocate a new array. (I'm ignoring possible garbage collection overhead).
System.arraycopy is a native call (that apparently uses memcpy). Even with the JNI overhead, System.arraycopy runs faster than Arrays.fill(). Unfortunately, it's still slower to call System.arraycopy() than it is to just allocate a new array.
So, the crux of the problem is that the heap allocations are too slow, and the existing means for bulk setting the elements of an array are even slower. Why doesn't the virtual machine have explicit support for both System.arraycopy() and Arrays.fill() so that they are performed with ultra-efficient memsets and memcpys and sans the method call and JNI overhead? I.E. something along the lines of two new JVM instructions - aarraycpy/aarrayset (and all of their primitive brethern).
God bless,
-Toby Reyelts

A newly allocated array begins its life with null in its elements. There is no need to fill it with null.
As Michael already stated, I'm not redundantly resetting all of the elements to null. Here's some code that demonstrates my point. You'll have to replace my PerfTimer with your own high performance timer. (i.e. sun.misc.Perf or whatever) Also note that the reason I'm only allocating half the array size in allocTest is to more accurately model my problem. The size of the array I need to allocate is variable. If I allocate the array outside of the function, I'll have to allocate it at a maximum. If I allocate inside the function, I can allocate it at exactly the right size.import java.util.*;
public class AllocTest {
private static final int count = 100000;
public static void main( String[] args ) {
 for ( int i = 0; i < 10; ++i ) {
 allocTest();
 double allocStartTime = PerfTimer.time();
 allocTest();
 double allocTime = PerfTimer.time() - allocStartTime;
 for ( int i = 0; i < 10; ++i ) {
 copyTest();
 double copyStartTime = PerfTimer.time();
 copyTest();
 double copyTime = PerfTimer.time() - copyStartTime;
 for ( int i = 0; i < 10; ++i ) {
 fillTest();
 double fillStartTime = PerfTimer.time();
 fillTest();
 double fillTime = PerfTimer.time() - fillStartTime;
 System.out.println( "AllocTime (ms): " + allocTime / PerfTimer.freq() * 1000 );
 System.out.println( "CopyTime (ms): " + copyTime / PerfTimer.freq() * 1000 );
 System.out.println( "FillTime (ms): " + fillTime / PerfTimer.freq() * 1000 );
private static void allocTest() {
 for ( int i = 0; i < count; ++i ) {
 Object[] objects = new Object[ 8 ];
private static void copyTest() {
 Object[] objects = new Object[ 15 ];
 Object[] emptyArray = new Object[ 15 ];
 for ( int i = 0; i < count; ++i ) {
 System.arraycopy( emptyArray, 0, objects, 0, emptyArray.length );
private static void fillTest() {
 Object[] objects = new Object[ 15 ];
 for ( int i = 0; i < count; ++i ) {
 Arrays.fill( objects, null );
}I getH:\>java -cp . AllocTest
AllocTime (ms): 9.749283777686829
CopyTime (ms): 13.276827082771694
FillTime (ms): 16.581995756443906So, to restate my point, all of these times are too slow just to perform a reset of all of the elements of an array. Since AllocTime actually represents dynamic heap allocation its number is good for what it does, but it's far too slow for simply resetting the elements of the array.
CopyTime is far too slow for what it does. It should be much faster, because it should essentially resolve to an inline memmove. The reason it is so slow is because there is a lot of call overhead to get to the function that does the actual copy, and that function ends up not being an optimized memmove. Even so, one on one, System.arraycopy() still beats heap allocation. (Not reflected directly in the times above, but if you rerun the test with equal array sizes, CopyTime will be lower than AllocTime).
FillTime is unbelievably slow, because it is a simple Java loop. FillTime should be the fastest, because it is the simplest operation and should resolve to an inline memset. Fills should run in single-digit nanosecond times.
God bless,
-Toby Reyelts

How to copy an array element in one class to an array in another class?

Hi,
I have a ClassRoom class that stores a list of Student objects in an array. How would I copy a Student object from the Student[] array in the ClassRoom class to an array in another class?
Is it something like this:
System.arraycopy(Students, 2, AnotherClass.Array, 0, 2);In an array do the items get copied over existing array elements or can the be added to the end? If so, how would I specify add copied object reference to the end of the array in the other class?

drew22299 wrote:
Hi,
I have a ClassRoom class that stores a list of Student objects in an array. How would I copy a Student object from the Student[] array in the ClassRoom class to an array in another class?
Is it something like this:
System.arraycopy(Students, 2, AnotherClass.Array, 0, 2);In an array do the items get copied over existing array elements or can the be added to the end? If so, how would I specify add copied object reference to the end of the array in the other class?System.arrayCopy will overwrite whatever is already in the array. It is your job to make sure it copies into the proper array location.
That being said, you're only moving a single student. This is not something you would use arrayCopy for, as you can just do that with simple assignment. Also, you should consider giving Class a method to add a student to its student list, as the class should know how many students it has and can easily "append" to the array.
Note: I hope you noticed the quotes around append. Java's arrays are fixed size. Once allocated, their size cannot change. You may want to consider using one of the List implementations (ArrayList, for example) instead.

ArrayStoreException by System.arraycopy

Hi!
I've made a simple code, which uses System.arraycopy, but it constantly throws ArrayStoreException, even though I can't see any reason for this.
(I've even run through it and watched the variables at breakpoints.) It seems as if it cannot convert Integer to Integer, but why?
 My code is here:
 import java.lang.reflect.Array;
public class ArrayHandler {
 public static void main(String[] args) {
 try {
 Integer[] startArray=new Integer[]{new Integer(1)};
 Integer[] endArray=new Integer[]{new Integer(2)};
 Object[] result=new ArrayHandler().appendArray(startArray, endArray);
 }catch(Throwable exception){
 exception.printStackTrace();
http://java.sun.com/j2se/1.3/docs/api/java/lang/System.html#arraycopy%28java.lang.Object,%20int,%20java.lang.Object,%20int,%20int%29
Otherwise, if any of the following is true, an ArrayStoreException is thrown and the destination is not modified:
 * The src argument refers to an object that is not an array.
 * The dst argument refers to an object that is not an array.
 * The src argument and dst argument refer to arrays whose component types are different primitive types.
 * The src argument refers to an array with a primitive component type and the dst argument refers to an array with a reference component type.
 * The src argument refers to an array with a reference component type and the dst argument refers to an array with a primitive component type.
 Otherwise, if any actual component of the source array
 from position srcOffset through srcOffset+length-1
 cannot be converted to the component type of the destination array by assignment conversion,
 an ArrayStoreException is thrown.
 In this case, let k be the smallest nonnegative integer less than length
 such that src[srcOffset+k] cannot be converted to the component type of the destination array;
 when the exception is thrown,
 source array components from positions srcOffset through srcOffset+k-1
 will already have been copied to destination array positions dstOffset through dstOffset+k-1
 and no other positions of the destination array will have been modified.
 (Because of the restrictions already itemized,
 this paragraph effectively applies only to the situation
 where both arrays have component types that are reference types.)
 public Object[] appendArray(Object[] startArray,Object[] endArray) {
 Object[] outputArray=startArray;
 Class startArrayClass=startArray.getClass();
 System.out.println(startArrayClass);
 Class endArrayClass=startArray.getClass();
 System.out.println(endArrayClass);
 if(startArrayClass !=endArrayClass){
 //throw new Exception("startArrayClass !=endArrayClass");
 }else{
 try{
 outputArray=(Object[])Array.newInstance(startArrayClass, startArray.length+endArray.length);
 System.arraycopy(startArray,0,outputArray,0,startArray.length);
 System.arraycopy(endArray,0,outputArray,startArray.length,endArray.length);
 return outputArray;
 }catch(Throwable exception){
 exception.printStackTrace();
 return outputArray;
 }//appendArray
}Could anybody share his experience, please.
My best regards.

astlanda wrote:(I've even run through it and watched the variables at breakpoints.)Thank's for your time.
I'm using Eclipse and I know a bit how to debug with it.
Everything was as expected, but I can't see into a native method like
 * Copies an array from the specified source array, beginning at the
 * specified position, to the specified position of the destination array.
 * A subsequence of array components are copied from the source
 * array referenced by <code>src</code> to the destination array
 * referenced by <code>dest</code>. The number of components copied is
 * equal to the <code>length</code> argument. The components at
 * positions <code>srcPos</code> through
 * <code>srcPos+length-1</code> in the source array are copied into
 * positions <code>destPos</code> through
 * <code>destPos+length-1</code>, respectively, of the destination
 * array.
 * 
 * If the <code>src</code> and <code>dest</code> arguments refer to the
 * same array object, then the copying is performed as if the
 * components at positions <code>srcPos</code> through
 * <code>srcPos+length-1</code> were first copied to a temporary
 * array with <code>length</code> components and then the contents of
 * the temporary array were copied into positions
 * <code>destPos</code> through <code>destPos+length-1</code> of the
 * destination array.
 * 
 * If <code>dest</code> is <code>null</code>, then a
 * <code>NullPointerException</code> is thrown.
 * 
 * If <code>src</code> is <code>null</code>, then a
 * <code>NullPointerException</code> is thrown and the destination
 * array is not modified.
 * 
 * Otherwise, if any of the following is true, an
 * <code>ArrayStoreException</code> is thrown and the destination is
 * not modified:
 * <ul>
 * <li>The <code>src</code> argument refers to an object that is not an
 * array.
 * <li>The <code>dest</code> argument refers to an object that is not an
 * array.
 * <li>The <code>src</code> argument and <code>dest</code> argument refer
 * to arrays whose component types are different primitive types.
 * <li>The <code>src</code> argument refers to an array with a primitive
 * component type and the <code>dest</code> argument refers to an array
 * with a reference component type.
 * <li>The <code>src</code> argument refers to an array with a reference
 * component type and the <code>dest</code> argument refers to an array
 * with a primitive component type.
 * </ul>
 * 
 * Otherwise, if any of the following is true, an
 * <code>IndexOutOfBoundsException</code> is
 * thrown and the destination is not modified:
 * <ul>
 * <li>The <code>srcPos</code> argument is negative.
 * <li>The <code>destPos</code> argument is negative.
 * <li>The <code>length</code> argument is negative.
 * <li><code>srcPos+length</code> is greater than
 * <code>src.length</code>, the length of the source array.
 * <li><code>destPos+length</code> is greater than
 * <code>dest.length</code>, the length of the destination array.
 * </ul>
 * 
 * Otherwise, if any actual component of the source array from
 * position <code>srcPos</code> through
 * <code>srcPos+length-1</code> cannot be converted to the component
 * type of the destination array by assignment conversion, an
 * <code>ArrayStoreException</code> is thrown. In this case, let
 * k be the smallest nonnegative integer less than
 * length such that <code>src[srcPos+</code>k<code>]</code>
 * cannot be converted to the component type of the destination
 * array; when the exception is thrown, source array components from
 * positions <code>srcPos</code> through
 * <code>srcPos+</code>k<code>-1</code>
 * will already have been copied to destination array positions
 * <code>destPos</code> through
 * <code>destPos+</code>k<code>-1</code> and no other
 * positions of the destination array will have been modified.
 * (Because of the restrictions already itemized, this
 * paragraph effectively applies only to the situation where both
 * arrays have component types that are reference types.)
 * @param src the source array.
 * @param srcPos starting position in the source array.
 * @param dest the destination array.
 * @param destPos starting position in the destination data.
 * @param length the number of array elements to be copied.
 * @exception IndexOutOfBoundsException if copying would cause
 * access of data outside array bounds.
 * @exception ArrayStoreException if an element in the <code>src</code>
 * array could not be stored into the <code>dest</code> array
 * because of a type mismatch.
 * @exception NullPointerException if either <code>src</code> or
 * <code>dest</code> is <code>null</code>.
 public static native void arraycopy(Object src, int srcPos,
 Object dest, int destPos,
 int length);

System.arraycopy()

I have an array of 1000 ints:
int[] a = new int[1000];After I fill it with random integer values, I want to sort it with one method iteratively and one method recursively.
It was suggested to me to use System.arraycopy(src, srcPos, dest, destPos, length) to make a copy of the array and then pass it to the two different methods.
How can I go about doin this....

Here's a demo:
        int[] array = {5,3,1,2,4};
        int[] copy = new int[array.length];
        System.arraycopy(array, 0, copy, 0, copy.length);
        System.out.println("array -> "+java.util.Arrays.toString(array));
        System.out.println("copy -> "+java.util.Arrays.toString(copy));

System.arraycopy overheads

I was just wondering if anyone knows anything about the overhead of using System.arraycopy.
I have rather large arrays in a loop - and it appears that manually looping through to copy the array gives better performance than use of System.arraycopy.
Is this actually the case (i.e. does the array copy actually implement a system call?) - or are my observations incorrect.
Thanks

System.arraycopy is a native method and therefore has a significant overhead to the method call. It looks like the native compiler produces code that is as good or better than the native code provided by the system, so the call to native code is actually slower than Java code. This is what the compiler experts have been saying about Java all along -- eventually Java will be as fast or faster than native code. In the case of a simple method like arraycopy, it looks as though it's true now!

How does System.arraycopy() work?

Anyone know how System.arraycopy() work?
Does it call constructor of each element of src array to make a deep copy?
Or does it, somehow, make a copy of content of memori location in which every
element of src array is stored and than assign that elements to dest array?
Thanks.

Hi,
The method does only copy primitives orreferences,
it does not create new objects.
KajSo, if I want to make a copy of an array that stores
other than primitives I need to do it manualy, not
using System.arraycopy() ? Right?It depends on if you want a deep copy or not. (Yes, you need to do it by hand if you want a deep copy)
Kaj

The System.arraycopy Functionality and copying array question

When created arrays such as String[] myStringArray (for example), is it general good practice to use the System.arraycopy function to copy the array?
Why isn't it good practice to use equal instead? Would this work just as well?
String[] myStringArray = new String[] { "My", " Test"};
String[] myStringArrayCopy = new String[myStringArray.length};
myStringArrayCopy = myStringArrayCopy;Or is that just going to make them the same element in memory and if I change myStringArray in antoher part of the program that means myStringArrayCopy will change as well since it is the same thing?

Youre right, the equals sign just assigns the new array same reference in memory as the old array so they are pointing to the same data.
Im 90% sure of that.
If you want to work with an array without changing the original array id suggest using the System.arraycopy method. If you dont mind the contents changing then use the = sign..(but then why use a new array at all?)
Hope this helps, if not theres loads of more experienced people on the boards...
Ocelot

System.arraycopy for arrays of 2 dimensions?

Can it be used for 2 dimensional arrays? How? My problem becomes more specific what the length parameter concerns.
Thanks
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

That means, that if i want to create a deep copy of a 2dimensional array, i have to:
-either create a new array, scan the first one and place the values in the new one
-or do something like this:
 Object[][] gameBoardCopy()
 Object[][] cloneBoard=new Object[8][8];
 System.arraycopy(this.board, 0, cloneBoard, 0, 8);
 for (int i=0; i<8; i++)
 System.arraycopy(this.board, 0, cloneBoard[i],0, 8);
What do you suggest?

How do I copy an array from a website to Excel using Firefox

Was running Firefox on Windows Vista. I could copy an array from finance.yahoo.com into an Excel spreadsheet by selecting the array with control key down then clicking on edit - copy selected cells, then pasting into an Excel sheet. I only had to tell it the upper left cell and the whole array went in properly
Now trying to do the same thing on a new machine running Windows 7, but the "copy selected cells" option is not available in the edit menu. Is there a way to copy an array with Firefox and Windows 7? These are big arrays. One cell at a time is out of the question.

Try this Add-on --> https://addons.mozilla.org/en-US/firefox/addon/dafizilla-table2clipboard/
'''If this reply solves your problem, please click "Solved It" next to this reply when signed-in to the forum.'''
Not related to your question, but...
You may need to update some plug-ins. Check your plug-ins and update as necessary:
*Plug-in check --> http://www.mozilla.org/en-US/plugincheck/
*Adobe Shockwave for Director Netscape plug-in: [https://support.mozilla.org/en-US/kb/Using%20the%20Shockwave%20plugin%20with%20Firefox#w_installing-shockwave Installing ('''''or Updating''''') the Shockwave plugin with Firefox]
*'''''Adobe PDF Plug-In For Firefox and Netscape''''': [https://support.mozilla.org/en-US/kb/Using%20the%20Adobe%20Reader%20plugin%20with%20Firefox#w_installing-and-updating-adobe-reader Installing/Updating Adobe Reader in Firefox]
*Shockwave Flash (Adobe Flash or Flash): [https://support.mozilla.org/en-US/kb/Managing%20the%20Flash%20plugin#w_updating-flash Updating Flash in Firefox]
*Next Generation Java Plug-in for Mozilla browsers: [https://support.mozilla.org/en-US/kb/Using%20the%20Java%20plugin%20with%20Firefox#w_installing-or-updating-java Installing or Updating Java in Firefox]

I have copied my CDs into iTunes (currently running v11) to play on my iPod. I have now bought a non Apple mp3 player to use when I am out running. How can I copy the many tracks I want from iTunes onto the new player?

I have copied my CDs into iTunes (currently running v11) to play on my iPod. I have now bought a non Apple mp3 player to use when I am out running. How can I copy the many tracks I want from iTunes onto the new player?
Thanks

I tried Notpod but can't get it to work. Part of the problem, I suspect, is that I can't create a folder on my player (a SanDisk Clip+). I also can't do this in Windows Explorer. Whilst I can see the Clip+ in Explorer, the option to create a new folder isn't there.
The error mesag I get in Notpod is:
"Unhandled exception has occurred in your application. If you click Continue, the application will ignore this error and attempt to continue. If you click Quit the application will close immediately.
InvalidArgument=Value of '0' is not valid for 'SelctedIndex'. Parameter name: SelectedIndex"
Then, when I plug the Clip+ into a USB port, iTunes thinks it is my iPad - which is because, I guess, Notpod hasn't worked.
I can drag and drop files from the Music folder where my iTunes tracks are stored onto the Clip+ and they get converted but I'd rather synchronise a Playlist from iTunes if I can.
Thanks anyone who can help

HT201317 When I view photos on my devices some are not oriented correctly. I used Picassa to turn all photos upright and then copied those photos into the upload file but they are still not corrected when viewed on my devices (ipads)

When I view photos on my devices some are not oriented correctly. I used Picassa to turn all photos upright and then copied those photos into the upload file but they are still not corrected when viewed on my devices (ipads)

Generally I would not use Facebook for sharing any photos, it compresses the photos substantially, and when you have shadows and dark colours you get visible "bands" where there should be subtle gradients, ie at sunsets and sunrises.
It sounds like you are using two methods to upload to Facebook:
1. Sharing from within Aperture, which basically syncs Facebook with your Aperture album, so any changes made at either end gets synced, hence the deletions from Albums, although the original file should still be in your library, just removed rom the album. It is like a playlist in iTunes.
2. Exporting pics and uploading to Facebook from the browser.
I am not sure how method 1 gets compressed, but I know that uploading hi-res jpegs to Facebook using method 2 results in poor quality images.
I wouldn't even bother comparing option 1 or 2, and they will both be poor images once you view them on Facebook, as opposed to viewing uploaded images on proper image sharing / hosting sites.
Your problem is not with Aperture, it is using Facebook for showing your work.
If you export pics form Aperture at high res jpegs or TIFFs your images will be fine.
If you insist to use Facebook as your way to share your work, then your workflow should be this:
1. Right click images you want to share.
2. Select Export version.
3. Export as 100% size and ensure the export settings are set at 100% quality.
4. Upload this pic into Facebook.
This will get you the best image size and resolution on Facebook.
See how you go.

Using System.arraycopy to copy an array into itself.

Similar Messages

Maybe you are looking for