Discussion :

[CKLN00]

Salut a toutes et a tous,
voici mon problème : je doit créer un tableau de bytes de taille 16 que je remplirais.*Ensuite je voudrais crée 4 nouveaux tableaux de bytes de taille 4 qui pointerais sur des sous-partie du premier tableau.
exemple :
byte[] monGrandTableau = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 10, 110, 120, 13, 14, 15};
byte[] sousPartie1 = new byte[4];
byte[] sousPartie2 = new byte[4];
byte[] sousPartie3 = new byte[4];
byte[] sousPartie4 = new byte[4];

sousPartie1 = …
sousPartie2 = …
sousPartie3 = …
sousPartie4 = …

contrainte :
- tout mes tableau doivent être de type byte
- je ne doit surtout PAS recopier de données

Est-ce possible si oui comment ?

d'avance merci

[thelvin]

Est-ce possible si oui comment ?

Pas avec des tableaux, non. Les tableaux n'ont pas de mécanisme de "vue," que ce soit d'une plage limitée de leurs index ou quoi que ce soit d'autre.

Quelque chose de ce genre peut être fait avec des List, à l'aide de leur méthode subList().
Toutefois, une List ne peut pas contenir de type primitif, et il faudra donc utiliser leur type objet wrappeur à la place. Dans le cas présent, une List<Byte>.

[SamSer]

Ca?

//Tableau contient data
byte[] monGrandTableau = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 10, 110, 120, 13, 14, 15};
//Chaque sous partie contient les index de grand tableau(pointeurs?)
byte[] sousPartie1 = {0,1,2,3};
byte[] sousPartie2 = {4,5,6,7};
byte[] sousPartie3 = {8,9,10,11};
byte[] sousPartie4 = {12,13,14,15};

Pour appeler, tu ferais un truc du genre:
system.out.println(monGrandTableau[sousParties1[1]]);

---

Si c'est ça que tu demandais ->

[CKLN00]

malheureusement le but de la manœuvre est d'alimenter une fonction qui a besoin de byte[] en entré tout en économisant la mémoire en ram (les sous tableau de bytes devant au final contenir des images de grande taille).

Les tableaux n'ont pas de mécanisme de "vue"

de toute façon les sous-tableau ne devais pas êtres de simples vue mais permettre potentiellement de modifier leur contenue (et donc celui du grand tableau).

Il est donc impossible en java d'utiliser des pointeurs pour construire des tableaux et c'est dommage je vous remercie tout les 2 (meme si SamSer avais pas vraiment compris :p) et

[Pill_S]

hello,

relis la réponse de thelvin: on peut le faire, mais pas avec des tableaux, avec des listes et la méthode subList, qui retourne une vue de la liste principale mais qui ne duplique PAS le tableau ou la structure de pointeurs sous-jaçent (toute modif dans une liste obtenue avec subList est repercutée dans la liste de base).

Concernant le typage en Byte au lieu de byte, c'est transparent grâce à l'auto(un)boxing de java 5 donc on peut les manipuler "comme si" c'était des byte

[Logan Mauzaize]

Si t'as des fonctions qui manipulent des tableaux pourquoi ne pas utiliser deux paramètres supplémentaires "int start" et "int length" comme c'est fait dans l'API Java ?

Sinon pourquoi ne pas créer une sorte de BitSet mais gestion de "range" ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
public interface BitArray
{
   public byte get(int index);
   public byte set(int index, byte b);
   public BitArray range(int start, int length);
   public int length();
}
 
public class BitArrayImpl
{
  private byte[] bytes;
  public BitArrayImpl(final byte[] bs)
  {
    bytes = bs;
  }
 
  public byte get(int index)
  {
     return bytes[index];
  }
 
  public byte set(index index, byte b)
  {
    byte old = bytes[index];
    bytes[index] = b;
    return old;
  }
 
  public int length()
  {
    return bytes.length;
  }
 
  public BitArray range(int start, int length)
  {
    return new BitArrayRange(this, start, length);
  }
}
 
public class BitArrayRange
{
  private BitArray underlying;
  private int start;
  private int length;
  public BitArrayRange(BitArray array, int from, int count)
  {
     underlying = array;
     start = from;
     length = count;
  }
 
  public byte get(int index)
  {
     if (index >= length) throw new ArrayOutOfBoundsException();
     return underlying.get(start + index);
  }
 
  public byte set(index index, byte b)
  {
    if (index >= length) throw new ArrayOutOfBoundsException();
    return underlying.set(start + index, b);
  }
 
  public int length()
  {
    return length;
  }
 
  public BitArray range(int start, int length)
  {
    return new BitArrayRange(this, start, length);
  }
}

En prime tu peux gérer un tableau au délà de 2^32 élément en utilisant plusieurs tableaux et le type long.