mapy JAVA

0

mam jSONA:

"stages": [
	{"id_stage": 1,
	"stageTypes": {"id_stageType": "1", "Name": "separate"},
	"dateFrom": "2014-01-01",
	"dateTo": "2014-01-01",
	"sections": [
		{"id_section": 1, 
		"fn": 1,
		"tn": 1,
		"length": 1}
	],
	"tags": {"id_tag": "1", "description": "siema"},
	"photos": [
		{"id_photo": 1, 
		"photoTypes": {"id_photoType": "1", "Name": "landscape"},
		"maxZoomLevel": 4,
		"width": 55,
		"heigth": 22,
		"angle": 1}
	],
	"stat" : 2,
	"lon" : 1,
	"lat" : 1,
	"crgw" : 1,
	"lane" : 1}
	{"id_stage": 1,
	"stageTypes": {"id_stageType": "1", "Name": "separate"},
	"dateFrom": "2014-01-01",
	"dateTo": "2014-01-01",
	"sections": [
		{"id_section": 1, 
		"fn": 1,
		"tn": 1,
		"length": 1}
	],
	"tags": {"id_tag": "1", "description": "siema"},
	"photos": [
		{"id_photo": 1, 
		"photoTypes": {"id_photoType": "1", "Name": "landscape"},
		"maxZoomLevel": 4,
		"width": 55,
		"heigth": 22,
		"angle": 1}
	],
	"stat" : 2,
	"lon" : 1,
	"lat" : 1,
	"crgw" : 1,
	"lane" : 1}
	{"id_stage": 3,
	"stageTypes": {"id_stageType": "2", "Name": "panorama"},
	"dateFrom": "2015-07-09",
	"dateTo": "2015-07-09",
	"sections": [
		{"id_section": 1, 
		"fn": 1,
		"tn": 1,
		"length": 1}
	],
	"tags": {"id_tag": "2", "description": "most"},
	"photos": [
		{"id_photo": 6, 
		"photoTypes": {"id_photoType": "2", "Name": "surface"},
		"maxZoomLevel": 11,
		"width": 1,
		"heigth": 11,
		"angle": 1}
	],
	"stat" : 3,
	"lon" : 1,
	"lat" : 1,
	"crgw" : 1,
	"lane" : 1}
]

jak widać niektóre elementy powtarzają się np id_stage = 1 kilka razy ponieważ scena zawiera kilka zdjęć.
Chciałbym żeby tabela stage występowała raz i wiem że mozna uzyc do tego map tylko problem polega na tym ze za bardzo nie wiem jak ?

0 
details += new StringBuffer("\t{\"id_stage\": ")
.append(rs.getString("id_stage")+",\n")
.append("\t\"stageTypes\": ").append("{\"id_stageType\": " ).append("\""+rs.getString("id_stagetype")+"\""+","+" ").append("\"Name\": ").append("\""+rs.getString("name")+"\""+"}"+",\n")
.append("\t\"dateFrom\": ").append("\""+rs.getString("dateFrom")+"\""+",\n")
.append("\t\"dateTo\": ").append("\""+rs.getString("dateTo")+"\""+",\n")
.append("\t\"sections\": [\n").append("\t\t{\"id_section\": " ).append(rs.getString("id_section")+","+" "+"\n").append("\t\t\"fn\": ")
.append(rs.getString("fn")+",\n").append("\t\t\"tn\": ").append(rs.getString("tn")+",\n").append("\t\t\"length\": ").append(rs.getString("length")+"}"+"\n"+"\t],\n")
.append("\t\"tags\": [\n").append("\n"+"\t]"+"\n")
.append("\t\"photos\": [\n").append("\t\t{\"id_photo\": " ).append(rs.getString("id_photo")+","+" "+"\n").append("\t\t\"photoTypes\": ")
.append("{\"id_photoType\": " ).append("\""+rs.getString("id_phototype")+"\""+","+" ").append("\"Name\": ").append("\""+rs.getString("nametype")+"\""+"}"+",\n")
.append("\t\t\"maxZoomLevel\": ").append(rs.getString("maxzoomlevel")+",\n").append("\t\t\"width\": ").append(rs.getString("width")+",\n")
.append("\t\t\"heigth\": ").append(rs.getString("height")+",\n").append("\t\t\"angle\": ").append(rs.getString("angle")+"}"+"\n"+"\t],\n")
.append("\t\"stat\" : ").append(rs.getString("stat")+",\n")
.append("\t\"lon\" : ").append(rs.getString("lon")+",\n")
.append("\t\"lat\" : ").append(rs.getString("lat")+",\n")
.append("\t\"crgw\" : ").append(rs.getString("crgw")+",\n")
.append("\t\"lane\" : ").append(rs.getString("lane")+"}\n").toString();
1

Weź biblioteke do JSONow, uprosci Ci ten kod.

Bardziej automatyczne:
http://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

Bardziej ręczne:
http://www.tutorialspoint.com/json/json_java_example.htm

Co do powtarzania idikow, problem prawdopodobnie z zapytaniem SQL.

0

Jeśli się nie mylę to trudno byłoby to tak zrobić bo się po prostu nie da SQLem :P Dałoby się agregować samochody w jeden wynik ale to nie o to tu chodzi bo to nie jest zwykły string.

W tym wypadku trzeba obrobić dane z ResultSeta.
Wspominałeś o mapach, jeśli chcesz tak zrobić to

Map<Osoba, List<Samochod>>

będzie prawdopodobnie poprawnym rozwiązaniem.
Po prostu przeiteruj przez ResultSeta, pseudokod:

  1. Jesli w mapie nie ma danej osoby to dodaj pusta liste samochodow
  2. Dodaj do listy samochodow, aktualny samochod z iteracji.

Jeśli stworzysz oddzielną klasę Osoba i chcesz ją wykorzystać jako klucz w mapie to poczytaj najpierw o hashCode i equals.

0 
 while (rs.next()) {
      	
String photo = new StringBuffer("\t\"photos\": [\n").append("\t\t{\"id_photo\": " ).append(rs.getString("id_photo")+","+" "+"\n").append("\t\t\"photoTypes\": ")
.append("{\"id_photoType\": " ).append("\""+rs.getString("id_phototype")+"\""+","+" ").append("\"Name\": ").append("\""+rs.getString("nametype")+"\""+"}"+",\n")
.append("\t\t\"maxZoomLevel\": ").append(rs.getString("maxzoomlevel")+",\n").append("\t\t\"width\": ").append(rs.getString("width")+",\n")
.append("\t\t\"heigth\": ").append(rs.getString("height")+",\n").append("\t\t\"angle\": ").append(rs.getString("angle")+"},"+"\n"+"\t\n")
.toString();	


String photo2 = new StringBuffer("\t\t{\"id_photo\": " ).append(rs.getString("id_photo")+","+" "+"\n").append("\t\t\"photoTypes\": ")
.append("{\"id_photoType\": " ).append("\""+rs.getString("id_phototype")+"\""+","+" ").append("\"Name\": ").append("\""+rs.getString("nametype")+"\""+"}"+",\n")
.append("\t\t\"maxZoomLevel\": ").append(rs.getString("maxzoomlevel")+",\n").append("\t\t\"width\": ").append(rs.getString("width")+",\n")
.append("\t\t\"heigth\": ").append(rs.getString("height")+",\n").append("\t\t\"angle\": ").append(rs.getString("angle")+"},"+"\n"+"\t\n")
.toString();	


String stages = new StringBuffer("\t{\"id_stage\": ")
.append(rs.getString("id_stage")+",\n")
.append("\t\"stageTypes\": ").append("{\"id_stageType\": " ).append("\""+rs.getString("id_stagetype")+"\""+","+" ").append("\"Name\": ").append("\""+rs.getString("name")+"\""+"}"+",\n")
.append("\t\"dateFrom\": ").append("\""+rs.getString("dateFrom")+"\""+",\n")
.append("\t\"dateTo\": ").append("\""+rs.getString("dateTo")+"\""+",\n")
.append("\t\"sections\": [\n").append("\t\t{\"id_section\": " ).append(rs.getString("id_section")+","+" "+"\n").append("\t\t\"fn\": ")
.append(rs.getString("fn")+",\n").append("\t\t\"tn\": ").append(rs.getString("tn")+",\n").append("\t\t\"length\": ").append(rs.getString("length")+"}"+"\n"+"\t],\n")
.append("\t\"tags\": ").append("{\"id_tag\": " ).append("\""+rs.getString("id_tag")+"\""+","+" ").append("\"description\": ").append("\""+rs.getString("description")+"\""+"}"+",\n").toString();
	


        	
String stagescd = new StringBuffer("\t\"lon\" : ").append(rs.getString("lon")+",\n")
.append("\t\"lat\" : ").append(rs.getString("lat")+",\n")
.append("\t\"crgw\" : ").append(rs.getString("crgw")+",\n")
.append("\t\"lane\" : ").append(rs.getString("lane")+"}\n").toString();
	    		
	    				
	        	if(map.containsKey(stages))
	        	{	  
	        		details += map.put(stages, photo2);
	        	} 
	        	else
	        	{ 
	        		details += map.put(stages, stages);
	        		details += map.put(stages, photo);	
	        		details += map.put(stages, stagescd);
	    
	        	}
	        }
	        details += "\n]\n";

Zrobiłem coś takiego ale nie zwraca ostatniego "samochodu"

0
  1. Proszę zainwestuj w ta biblioteke do JSONa bo tych appendow nie da sie czytac :) Ułatwi Ci, serio.
  2. Podaj wynik z ResultSeta - czyli pokaż taką tabelkę z kolumnami i wierszami, może być kilka ale żeby zaprezentować problem. Powiedz co chcesz z tego mieć na podstawie 2-3 rekordów.

Jak zapewnisz 2 punkt to będzie o wiele łatwiej Ci pomóc.

0

jak skorzystac z tej biblioteki ?

http://wrzucaj.net/rcN
to jest moja tabela z zapytaniem

jak widać do jednego "id_stage" jest przypisanych pare "id_photo" czyli kilka wierszy z tabeli photo.
przy normalnym wyswietleniu tego w JSONIE
cała sktruktura tabeli stage będzie sie powtarzała tyle razy ile wystepuje photo. a chciałbym zeby omijało to i wyświetlalo pokolei same photo:

normalnie wyświetla tak:

"stages": [
    {"id_stage": 1,
    "stageTypes": {"id_stageType": "1", "Name": "separate"},
    "dateFrom": "2014-01-01",
    "dateTo": "2014-01-01",
    "sections": [
        {"id_section": 1, 
        "fn": 1,
        "tn": 1,
        "length": 1}
    ],
    "tags": {"id_tag": "1", "description": "siema"},
    "photos": [
        {"id_photo": 1, 
        "photoTypes": {"id_photoType": "1", "Name": "landscape"},
        "maxZoomLevel": 4,
        "width": 55,
        "heigth": 22,
        "angle": 1}
    ],
    "stat" : 2,
    "lon" : 1,
    "lat" : 1,
    "crgw" : 1,
    "lane" : 1}
    {"id_stage": 1,
    "stageTypes": {"id_stageType": "1", "Name": "separate"},
    "dateFrom": "2014-01-01",
    "dateTo": "2014-01-01",
    "sections": [
        {"id_section": 1, 
        "fn": 1,
        "tn": 1,
        "length": 1}
    ],
    "tags": {"id_tag": "1", "description": "siema"},
    "photos": [
        {"id_photo": 1, 
        "photoTypes": {"id_photoType": "1", "Name": "landscape"},
        "maxZoomLevel": 4,
        "width": 55,
        "heigth": 22,
        "angle": 1}
    ],
    "stat" : 2,
    "lon" : 1,
    "lat" : 1,
    "crgw" : 1,
    "lane" : 1}
    {"id_stage": 3,
    "stageTypes": {"id_stageType": "2", "Name": "panorama"},
    "dateFrom": "2015-07-09",
    "dateTo": "2015-07-09",
    "sections": [
        {"id_section": 1, 
        "fn": 1,
        "tn": 1,
        "length": 1}
    ],
    "tags": {"id_tag": "2", "description": "most"},
    "photos": [
        {"id_photo": 6, 
        "photoTypes": {"id_photoType": "2", "Name": "surface"},
        "maxZoomLevel": 11,
        "width": 1,
        "heigth": 11,
        "angle": 1}
    ],
    "stat" : 3,
    "lon" : 1,
    "lat" : 1,
    "crgw" : 1,
    "lane" : 1}
]

a chciałbym, żeby wyglądało to tak :

"stages": [
    {"id_stage": 1,
    "stageTypes": {"id_stageType": "1", "Name": "separate"},
    "dateFrom": "2014-01-01",
    "dateTo": "2014-01-01",
    "sections": [
        {"id_section": 1, 
        "fn": 1,
        "tn": 1,
        "length": 1}
    ],
    "tags": {"id_tag": "1", "description": "siema"},
    "photos": [
        {"id_photo": 1, 
        "photoTypes": {"id_photoType": "1", "Name": "landscape"},
        "maxZoomLevel": 4,
        "width": 55,
        "heigth": 22,
        "angle": 1}
    
TUTAJ NIE POWTARZA SIĘ CAŁA TABELA STAGE TYLKO ODRAZU JEST DODANY SAM OBIEKT FOTO 

        {"id_photo": 15, 
        "photoTypes": {"id_photoType": "1", "Name": "landscape"},
        "maxZoomLevel": 4,
        "width": 55,
        "heigth": 22,
        "angle": 1}
    ],
    "stat" : 2,
    "lon" : 1,
    "lat" : 1,
    "crgw" : 1,
    "lane" : 1}
    {"id_stage": 3,
    "stageTypes": {"id_stageType": "2", "Name": "panorama"},
    "dateFrom": "2015-07-09",
    "dateTo": "2015-07-09",
    "sections": [
        {"id_section": 1, 
        "fn": 1,
        "tn": 1,
        "length": 1}
    ],
    "tags": {"id_tag": "2", "description": "most"},
    "photos": [
        {"id_photo": 6, 
        "photoTypes": {"id_photoType": "2", "Name": "surface"},
        "maxZoomLevel": 11,
        "width": 1,
        "heigth": 11,
        "angle": 1}
    ],
    "stat" : 3,
    "lon" : 1,
    "lat" : 1,
    "crgw" : 1,
    "lane" : 1}
]
1

Średnio chce mi się myśleć ale:

public class Photo{
   private int photoId;
   private int width;
   private int height;
   private String description;
   //itp. itd.
}

public class Stage{
   //pola dla stage + wygeneruj metody hashCode i equals bo obiekt bedzie kluczem w mapie!!!
}

wez teraz ResultSeta i zrob to tak najprosciej jak sie da zeby nie wprowadzac zbyt wielu zagadnien:


Map<Stage, List<Photo>> stageWithPhotos = new LinkedHashMap<>();

while(rs.next()){
   Stage stage = new Stage();
   stage.setStageId(rs.getInt("stage_id"));
   //ustawienie pozostalych danych itp. itd.

   Photo photo = new Photo();
   photo.setPhotoId(rs.getInt("photo_id"));
   //ustawienie pozostalych danych itp. itd.

   if(!stageWithPhotos.contains(stage)){
      stageWithPhotos.put(stage, new ArrayList<Photo>());
   }
   
   stageWithPhotos.get(stage).add(photo);
}

//tutaj masz juz dostepna mape, dla zadanego klucza masz powiazana liste zdjec
//teraz mozesz sobie iterowac po mapie i tworzyc swojego JSONa
0 
 while (rs.next()) {
	        	
	        	Stage stage = new Stage();
	        	stage.setId_stage(rs.getString("Id_stage"));
	        	
	        	
	        	Photo photo = new Photo();
	        	photo.setId_photo(rs.getString("id_photo"));
	        	
	        	if(!map.containsKey(stage)){
	        		map.put(stage, new ArrayList<Photo>());
	        	}
	        	 map.get(stage).add(photo);
	        	 
	        	 details += new StringBuffer("\t{\"id_stage\": ")
	    					.append(map.get(stage))+",\n".toString();
	        	 details += new StringBuffer("\t\"photos\": [\n").append("\t\t{\"id_photo\": " ).append(map.get(photo))+","+" "+"\n".toString();
	        }

chciałem zrobić cos takiego ale to wyswietla dziwne dane

0
  1. Nie wiem co to znaczy dziwne dane
  2. StringBuilder zamiast StringBuffera. W tym przypadku na 99% nie jest Ci potrzebna wolniejsza wersja synchronizowana tylko ta szybsza bez synchronizacji.
  3. Jak już masz tego buildera to weź zmienna details jako builder i wywal te pośrednie których teraz używasz. StringBuildera używasz, bo operacje łączeniach na czystych stringach są mało wydajne a w Twoim przypadku i tak tracisz te zalety.
  4. Buduj JSONa poza pętlą while, gdy masz już całą mapę ze wszystkimi danymi.
  5. Dociągnij biblioteke dla JSONa, na razie taką badziej ręczną https://code.google.com/p/json-simple/ i poczytaj jak tworzyc obiekty JSONowe
  6. Przykladowy kod wykorzystujacy tę bibliotekę (dosc slaba, korzystalem kiedys z troche lepszej do takiego recznego budowania JSONa)

package com.jpmorgan.sss.common;

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

public class test {

	public static void main(String[] args) {
		Stage stage1 = new Stage(1);
		List<Photo> photos1 = Arrays.asList(new Photo(1, 100, 120), new Photo(2, 200, 320));

		Stage stage2 = new Stage(2);
		List<Photo> photos2 = Arrays.asList(new Photo(3, 100, 120), new Photo(4, 200, 320));

		Map<Stage, List<Photo>> stageAndPhotos = new LinkedHashMap<>();
		stageAndPhotos.put(stage1, photos1);
		stageAndPhotos.put(stage2, photos2);

		JSONObject jsonResult = new JSONObject();
		JSONArray stagesArray = new JSONArray();
		jsonResult.put("stages", stagesArray);

		for (Entry<Stage, List<Photo>> entry : stageAndPhotos.entrySet()) {
			JSONObject stage = new JSONObject();
			JSONArray photos = new JSONArray();
			stage.put("stageId", entry.getKey().getStageId());
			stage.put("photos", photos);

			for (Photo photo : entry.getValue()) {
				JSONObject jsonPhoto = new JSONObject();
				jsonPhoto.put("photoId", photo.getPhotoId());
				jsonPhoto.put("width", photo.getWidth());
				jsonPhoto.put("height", photo.getHeight());
				photos.add(jsonPhoto);
			}

			stagesArray.add(stage);
		}

		System.out.println(jsonResult.toJSONString());
	}
}

Wynikiem bedzie cos takiego:

{
   "stages":[
      {
         "photos":[
            {
               "width":100,
               "photoId":1,
               "height":120
            },
            {
               "width":200,
               "photoId":2,
               "height":320
            }
         ],
         "stageId":1
      },
      {
         "photos":[
            {
               "width":100,
               "photoId":3,
               "height":120
            },
            {
               "width":200,
               "photoId":4,
               "height":320
            }
         ],
         "stageId":2
      }
   ]
}
0 
 while (rs.next()) {
	        	int id = rs.getInt("id_stage");
	        	
	        	String photo = new StringBuffer("\t\"photos\": [\n").append("\t\t{\"id_photo\": " )
        				....
	        	String photo2 = new StringBuffer("\t\t{\"id_photo\": " ).append(rs.getString("id_photo")...

	        	String stages = new StringBuffer("\t{\"id_stage\": ")...

	        	String stagescd = new StringBuffer("\t\"lon\" : ").append(rs.getString("lon")+",\n")...

	        	if(map.containsKey(id))
	        	{
	        		details += map.put(id, photo2);
	        		details += map.put(id, "");	
	        		
	        	}	     
	        	else
	        	{     
	        		details += map.put(id, stages);
	        		details += map.put(id, photo);
	        		details += map.put(id, "");
	        	} 
	        }

Podzieliłem to na części i niby wyświetla to dobrze ale nie do końca

0 
null	{"id_stage": 6,
	"stageTypes": {"id_stageType": "1", "Name": "separate"},
	"dateFrom": "2001-11-11",
	"dateTo": "2014-11-11",
	"sections": [
		{"id_section": 1, 
		"fn": 1,
		"tn": 1,
		"length": 1}
	],
	"tags": {"id_tag": "5", "description": "obiekt"},
	"photos": [
		{"id_photo": 9, 
		"photoTypes": {"id_photoType": "1", "Name": "landscape"},
		"maxZoomLevel": 22,
		"width": 11,
		"heigth": 12,
		"angle": 11},
	
	"lon" : 1,
	"lat" : 1,
	"crgw" : 1,
	"lane" : 1}
null	{"id_stage": 17,
	"stageTypes": {"id_stageType": "2", "Name": "panorama"},
	"dateFrom": "2001-11-12",
	"dateTo": "2005-05-11",
	"sections": [
		{"id_section": 2, 
		"fn": 2,
		"tn": 2,
		"length": 2}
	],
	"tags": {"id_tag": "16", "description": "obiekt"},
	"photos": [
		{"id_photo": 10, 
		"photoTypes": {"id_photoType": "1", "Name": "landscape"},
		"maxZoomLevel": 22,
		"width": 11,
		"heigth": 12,
		"angle": 11},
	
	"lon" : 1,
	"lat" : 1,
	"crgw" : 1,
	"lane" : 4}
		{"id_photo": 44, 
		"photoTypes": {"id_photoType": "1", "Name": "landscape"},
		"maxZoomLevel": 2,
		"width": 2,
		"heigth": 2,
		"angle": 2},
	
		{"id_photo": 45, 
		"photoTypes": {"id_photoType": "1", "Name": "landscape"},
		"maxZoomLevel": 2,
		"width": 23423,
		"heigth": 2,
		"angle": 2},
]

Problem polega na tym że w "id_stage" = 17 wyswietla po pierwszym photo dalsza czesc a powinno na samym koncu. i na poczatku kazdego "Stage" pojawia sie "null"

0

W komentarzu do przykladowego wykorzystania biblioteki do jsona, mowisz ze sam wrzucam a masz pobrac z bazy...

Czy ty czytales ze mowilem zebys najpierw przeiterowal przez ResultSet, stworzyl obiekty odpowiednich klas na podstawie rekordow z bazy i wrzucil je do mapy.
Nastepnie operujesz na mapie i masz wszystko ladnie.

0

Zrobiłem tak jak mi podpowiedziałeś. Utworzyłem klasy oraz dodałem pare kolumn na razie dla przykladu

 while (rs.next()) {
	        	Stage stage = new Stage();
	        	stage.setId_stage(rs.getString("Id_stage"));
	        	
	        	Photo photo = new Photo();
	        	photo.setId_photo(rs.getString("id_photo"));
	        	photo.setMaxzoomlewel(rs.getInt("maxzoomlewel"));
	        	photo.setAngle(rs.getInt("angle"));
	        	
	        	if(!map.containsKey(stage)){
	        		map.put(stage, new ArrayList<Photo>());
	        	}
	        	 map.get(stage).add(photo);	        	 
	        }
0

No teraz masz wszystko w mapie po której możesz iterować. Jesli chcesz robic to biblioteka do JSONa to ja pobierz i dodaj do classpath.

Glownym zyskiem przy wykorzystaniu tu mapy jest to ze masz wszystkie zdjecia dla danej sceny, nie pomiesza Ci sie podczas iterowania, nie zduplikuje itp itd. Przy tworzeniu bezposrednio z ResultSeta byloby duzo trudniej.


Map<Stage, List<Photo>> map= new LinkedHashMap<>();

for (Entry<Stage, List<Photo>> entry : map.entrySet()) {
   //entry.getKey to stage
   //entry.getValue to lista zdjec dla tego stage
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1