So, we have arrays and we have arraylists, and it's
a bit of a nuisance that we have both. Because it
means that we have to make a decision between them
whenever we want to collect elements. Generally, arraylists are more convenient
because they can grow and shrink. But there are a
few reasons why you might want to prefer arrays. First off, the
syntax for the brackets, is more compact. For example here,
we assign values one to values two and that's a bit
easier to read than the equivalent with arraylists, which
you see over here. Also, if you know exactly what
values you want in a collection, then arrays give you
an easier syntax. Here I have a string of workdays,
and I know exactly that I want these five
strings. No more, no less. I know what they are.
Then I can use this handy syntax, to construct an
array and initialize it right away. With an array list,
I would have to call the add method five times,
once for each of these strings. Another disadvantage of array lists
is that they don't work well with numbers. We have
never done that so far, but let's say we wanted to
collect Numbers in an array list, I'd have to do
something like this, and when you look carefully, you'll notice that
the double here, has an uppercase D. Normally, when we
want to have a floating point number, we write double with
a lowercase d, and you may recall that the
number types are not classes in Java. But inside, the
angle brackets here, I must put in a class.
An array list can only collect objects of a class.
So for every number time, There is a companion
class, called the wrapper class. And an object, of a
wrapper, just has some number inside. If you have
lots of numbers, say for the sake of the argument
you have, 1,000,000 values, it takes a lot more
space to store 1,000,000 wrappers each of which contains
a number, than it would be to use an
array That's contains the numbers directly. Most of the
time, we're not that concerned about efficiency, but when
you are, and need to collect a lot of
numbers, definitely use an array. In conclusion, use an
array list as a rule of thumb, unless you want
the nice syntax that an array gives you. You having the brackets, having the
initializers. Or you collect lots of numbers.
In that case, array lists are quite inefficient.
Bien, tenemos «arrays» y tenemos «array lists» y es un poco
molesto que tengamos ambas porque
significa que tenemos que tomar una decisión entre ellos
siempre que queramos recolectar elementos. En general, las «array lists» son más convenientes
porque pueden crecer y encogerse. Sin embargo, hay algunas
razones por las que podrían preferir las «arrays». En primer lugar, la
sintaxis con los corchetes es más compacta. Por ejemplo, en este caso
asignamos valores 1 a los valores 2 y eso es un poco
más fácil de leer que el equivalente con las «array lists» que
ven por acá. Además, si saben exactamente que
valores quieren en una colección, entonces las «arrays» les dan
una sintaxis más fácil. Esta es una cadena de días hábiles,
y sé exactamente que quiero estas cinco
cadenas. Ni mas, ni menos. Yo sé lo que son.
Entonces, puedo utilizar esta práctica sintaxis para construir un
«array» e iniciarla de inmediato. Con una «array list»,
Tendría que invocar al método «add» cinco veces,
una vez por cada una de estas cadenas. Otra desventaja de las «array lists»
es que no funcionan bien con números. Hasta el momento
no lo hemos hecho, pero digamos que quisiéramos
recolectar números en una «array list». Tendría que hacer
algo como esto, y cuando observan con cuidado, se darán cuenta de que
este doble, tiene una «D» mayúscula. Normalmente, cuando queremos
tener un número de punto flotante, se escribe con doble con
d minúscula, y pueden recordar que los
tipos de números no son clases en Java. Pero debo poner una clase dentro de
estos corchetes de ángulo.
Una «array list» solo puede recolectar objetos de una clase.
Así, por cada tipo de número, hay una clase compañera,
llamada la clase «Wrapper» (Envoltura). Y un objeto de una clase
Wrapper solo tiene algún número en su interior. Si tienen
muchos números, digamos que por poner un ejemplo, su argumento tiene
1,000,000 de valores, se necesita mucho más espacio
para almacenar 1,000,000 de «Wrappers», cada uno de los cuales contiene
un número, del espacio que se necesitaría para utilizar un
«array» que contiene los números directamente. La mayoría del tiempo
no nos preocupamos acerca de la eficiencia, pero cuando nos preocupamos
y necesitamos recolectar muchos
números, sin duda utilicen un «array». En conclusión, utilice una
«array list» como regla general, a menos que quieran
la sintaxis elegante que un «array» les da. Que ustedes tengan los corchetes, los
inicializadores. O que recolecten muchos números.
En ese caso, las «array lists» son bastante ineficientes.
Nous avons donc des tableaux
et nous avons des vecteurs,
et c'est un peu gênant d'avoir les deux
car ça signifie qu'il faut
choisir l'un des deux
chaque fois qu'on veut
collecter des éléments.
Généralement, les vecteurs
sont plus pratiques
parce qu'ils peuvent
s'agrandir et rétrécir.
Mais il y a quelques raisons pour
vouloir opter pour des tableaux.
Tout d'abord, la syntaxe pour
les crochets est plus compacte.
Par exemple, ici, nous assignons
valeurs 1 à valeurs 2
et c'est un peu plus facile à lire que
l'équivalent avec des vecteurs,
que vous voyez ici.
De plus, si vous savez exactement quelles
valeurs vous voulez dans une collection,
alors les tableaux vous donnent
une syntaxe plus facile.
Ici j'ai une chaîne de jours de travail
et je sais exactement que
je veux ces cinq chaînes,
ni plus ni moins.
Je sais ce qu'elles sont.
Ensuite, je peux utiliser
cette syntaxe pratique,
pour construire un tableau
et l'initialiser tout de suite.
Avec un vecteur, je devrais
appeler la méthode add cinq fois,
une fois pour chacune de ces chaînes.
Un autre inconvénient des vecteurs est
qu'ils ne fonctionnent pas
bien avec les nombres.
Nous n'avons jamais fait
cela jusqu'ici,
mais disons que nous voulions collecter
des nombres dans un vecteur,
je dois faire quelque chose comme ça,
et en regardant attentivement,
vous remarquerez que le double ici,
a un d majuscule.
D'habitude, quand on veut
un nombre à virgule flottante,
on écrit double avec un d minuscule
et pour rappel, les types de nombres
ne sont pas des classes dans Java.
Mais à l'intérieur des équerres ici,
je dois mettre dans une classe.
Un vecteur peut uniquement
collecter des objets d'une classe.
Donc, pour type de nombre,
il y a une classe d'accompagnement,
appelée la classe wrapper.
Et un objet, d'un wrapper, a juste
un certain nombre à l'intérieur.
Si vous avez beaucoup de nombres,
disons qu'à titre d'exemple,
vous avez un million de valeurs,
il faut beaucoup plus d'espace
pour stocker un million d'emballages
dont chacune contient un nombre,
que ce serait d'utiliser un tableau qui
contient les nombres directement.
La plupart du temps, nous ne sommes
pas si concernés par l'efficacité,
mais à contrario, quand vous avez besoin
de collecter beaucoup
de nombres,
utilisez alors un tableau.
En conclusion, utilisez un vecteur
en règle générale,
à moins que vous ne souhaitiez
la belle syntaxe d'un tableau.
Vous avez les parenthèses
ainsi que les initialiseurs.
Ou vous collectez beaucoup de chiffres.
Dans ce cas, les vecteurs
sont assez inefficaces.
私たちには配列とArrayListがあります
2つあるのは少し厄介です
というのも要素を集めたい時は常に
どちらかを選ぶ必要があるからです
一般的にはArrayListの方が
拡大、縮小できるため便利です
しかし配列の利点もいくつかあります
まず1つは角括弧を使うことで
構文がより簡潔になっている点です
例えばvalues[1]をvalues[2]に代入する場合
同じことを
ArrayListで表示したものより読みやすいです
またコレクションの中で必要な値が
はっきりしている時は
配列の方が簡単な構文になります
これは平日の文字列です 文字列は5つ必要だと
はっきりしています
これ以上でもこれ以下でもありません
この簡単な構文を使って迅速に配列を構成し
初期化できます ArrayListでは
それぞれの文字列ごとにaddメソッドを5回
呼び出さなければなりません
ArrayListのもう1つのデメリットは
数字との相性がよくないことです
今までやってきませんでしたが
ArrayListで数字を収集するとしましょう
このようなことをしなければなりません
このdoubleのDが大文字になっています
浮動小数点が必要な時は
通常小文字のdを使います
皆さんはJavaにおける数字の型は
クラスではないと記憶しているかもしれませんが
山括弧があるのでクラスを入れる必要があります
ArryListは
クラスのオブジェクトしか収集できません
すべての数字の型にはコンパニオンクラスがあり
ラッパークラスと呼ばれます
ラッパーのオブジェクトは
中にある数字を持ってます
数字をたくさん持っていれば
例えば1,000,000の値という引数があるとすると
数字を直接含む配列を使うよりも
1,000,000のラッパーを保存するには
たくさんの空間が必要です
普段私たちは効率のことにあまり気を配りませんが
効率性を気にしていたり
多くの数字を収集する必要がある時には
絶対に配列を使います
大ざっぱでいい時はArrayListを使います
配列を使えば角括弧や初期化子のある
きれいな構文が作れたり
たくさんの数字を収集できたりします
ArrayListでは効率が悪いです
배열과 배열 리스트가 있습니다. 배열을 표현하는 방법이 두 가지가 있어서
골칫거리가 될 수 있습니다. 왜냐하면 요소를 저장할 때
두 가지 방법에 대해서 항상 생각해 보아야 하기
때문입니다. 배열 리스트는 크게 또는 작게 하는 것이 자유로워서
더 일반적으로 많이 쓰입니다. 하지만 배열을 이용해야 할 몇 가지
이유가 있습니다. 첫 번째로,
대괄호를 이용한 문법이 더 쉽습니다. 예를 들어서,
values[2]를 values[1]에 저장하는 선언이고,
배열 리스트로 한 것 보다 훨씬 더 읽기
쉽습니다. 또한, 어떤 값을 저장하고 싶은지 알고
있다면, 배열로 하면 문법이 훨씬 더 쉬워
집니다. 평일을 저장하고 있는 문자열을 선언하고
이를 어떻게 이용해야 할지 저는 알고
있습니다. 무슨 값을 저장하고 있는지 알고 있습니다.
그럼 배열을 이렇게 바로 선언할 수
있습니다. 배열 리스트로 했다면
add 메소드를 다섯 번 호출해야
했습니다. 배열 리스트에 대한 또 다른 단점은,
숫자에 약하다는 것입니다. 지금까지
한 번도 안해봤지만, 배열 리스트에
숫자를 저장한다고 합시다. 이런 식으로
선언을 하고, 자세하게 보면, 여기에 있는
double은 d가 대문자입니다. 일반적으로
double의 d를 소문자로 해야 합니다. 자료 형은
클래스가 될 수 없다고 생각할 수
있습니다. 하지만 여기 안에는
클래스가 들어가야 합니다.
배열 리스트는 클래스의 객체를 저장할 수 있습니다.
그래서 하나의 숫자를 위해서 클래스의 친구인
래퍼 클래스가 있습니다. 래퍼 클래스의
객체 안에 숫자가 있습니다. 만약 많은
숫자가 있다면, 예를 들어
1,0000,000개의 매개변수 값이 있다면,
배열로 저장하는 것 보다 배열 리스트는
컴퓨터의 메모리를 굉장히
많이 잡아먹게 됩니다. 대부분의 경우에는
효율성에 대해서 생각하지 않지만, 효율성을
따져야 하고 굉장히 많은 숫자를 저장해야
한다면, 당연히 배열을 이용해야 합니다. 결론적으로,
배열과 같이 간단한 문법이 필요할 때 외에는
배열 리스트를 사용하면 됩니다. 대괄호, 인덱스 선언,
또는 많은 숫자를 저장할 때 배열 리스트를
사용하신다면, 굉장히 비효율적입니다.